stylus-source 0.15.4

data/lib/stylus/functions/index.styl

@@ -0,0 +1,123 @@
+
+vendors = moz webkit official
+
+// stringify the given arg
+
+-string(arg)
+  type(arg) + ' ' + arg
+
+// require a color
+
+require-color(color)
+  unless color is a 'color' 
+    error('RGB or HSL value expected, got a ' + -string(color))
+
+// require a unit
+
+require-unit(n)
+  unless n is a 'unit'
+    error('unit expected, got a ' + -string(n))
+
+// require a string
+
+require-string(str)
+  unless str is a 'string' or str is a 'ident'
+    error('string expected, got a ' + -string(str))
+
+// apply js Math function
+
+math(n, fn) 
+  require-unit(n)
+  require-string(fn)
+  -math(n, fn)
+
+// adjust the given color's property by amount
+
+adjust(color, prop, amount)
+  require-color(color)
+  require-string(prop)
+  require-unit(amount)
+  -adjust(color, prop, amount)
+
+// Math functions
+
+abs(n) { math(n, 'abs') }
+ceil(n) { math(n, 'ceil') }
+floor(n) { math(n, 'floor') }
+round(n) { math(n, 'round') }
+sin(n) { math(n, 'sin') }
+cos(n) { math(n, 'cos') }
+min(a, b) { a < b ? a : b }
+max(a, b) { a > b ? a : b }
+PI = -math-prop('PI')
+
+// return the sum of the given numbers
+
+sum(nums)
+  sum = 0
+  sum += n for n in nums
+
+// return the average of the given numbers
+
+avg(nums)
+  sum(nums) / length(nums)
+
+// color components
+
+alpha(color) { component(hsl(color), 'alpha') }
+hue(color) { component(hsl(color), 'hue') }
+saturation(color) { component(hsl(color), 'saturation') }
+lightness(color) { component(hsl(color), 'lightness') }
+
+// check if n is an odd number
+
+odd(n)
+  1 == n % 2
+
+// check if n is an even number
+
+even(n)
+  0 == n % 2
+
+// check if color is light
+
+light(color)
+  lightness(color) >= 50%
+
+// check if color is dark
+
+dark(color)
+  lightness(color) < 50%
+
+// desaturate color by amount
+
+desaturate(color, amount)
+  adjust(color, 'saturation', - amount)
+
+// saturate color by amount
+
+saturate(color, amount)
+  adjust(color, 'saturation', amount)
+
+// darken by the given amount
+
+darken(color, amount)
+  adjust(color, 'lightness', - amount)
+
+// lighten by the given amount
+
+lighten(color, amount)
+  adjust(color, 'lightness', amount)
+
+// return the last value in the given expr
+
+last(expr)
+  expr[length(expr) - 1]
+
+// join values with the given delimiter
+
+join(delim, vals...)
+  buf = ''
+  vals = vals[0] if length(vals) == 1
+  for val, i in vals
+    buf += i ? delim + val : val

data/lib/stylus/functions/url.js

@@ -0,0 +1,98 @@
+
+/*!
+ * Stylus - plugin - url
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Compiler = require('../visitor/compiler')
+  , nodes = require('../nodes')
+  , parse = require('url').parse
+  , extname = require('path').extname
+  , utils = require('../utils')
+  , fs = require('fs');
+
+/**
+ * Mime table.
+ */
+
+var mimes = {
+    '.gif': 'image/gif'
+  , '.png': 'image/png'
+  , '.jpg': 'image/jpeg'
+  , '.jpeg': 'image/jpeg'
+  , '.svg': 'image/svg+xml'
+};
+
+/**
+ * Return a url() function with the given `options`.
+ *
+ * Options:
+ *
+ *    - `limit` bytesize limit defaulting to 30Kb
+ *    - `paths` image resolution path(s), merged with general lookup paths
+ *
+ * Examples:
+ *
+ *    stylus(str)
+ *      .set('filename', __dirname + '/css/test.styl')
+ *      .define('url', stylus.url({ paths: [__dirname + '/public'] }))
+ *      .render(function(err, css){ ... })
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function(options) {
+  options = options || {};
+
+  var sizeLimit = options.limit || 30000
+    , _paths = options.paths || [];
+
+  function url(url){
+    // Compile the url
+    var compiler = new Compiler(url);
+    compiler.isURL = true;
+    var url = url.nodes.map(function(node){
+      return compiler.visit(node);
+    }).join('');
+
+    // Parse literal 
+    var url = parse(url)
+      , ext = extname(url.pathname)
+      , mime = mimes[ext]
+      , literal = new nodes.Literal('url("' + url.href + '")')
+      , paths = _paths.concat(this.paths)
+      , founds
+      , buf;
+
+    // Not supported
+    if (!mime) return literal;
+
+    // Absolute
+    if (url.protocol) return literal;
+
+    // Lookup
+    found = utils.lookup(url.pathname, paths);
+
+    // Failed to lookup
+    if (!found) return literal;
+
+    // Read data
+    buf = fs.readFileSync(found);
+
+    // To large
+    if (buf.length > sizeLimit) return literal;
+
+    // Encode
+    return new nodes.Literal('url("data:' + mime + ';base64,' + buf.toString('base64') + '")');
+  };
+
+  url.raw = true;
+  return url;
+};

data/lib/stylus/lexer.js

@@ -0,0 +1,728 @@
+
+/*!
+ * Stylus - Lexer
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Token = require('./token')
+  , nodes = require('./nodes')
+  , errors = require('./errors');
+
+/**
+ * Operator aliases.
+ */
+
+var alias = {
+    'and': '&&'
+  , 'or': '||'
+  , 'is': '=='
+  , 'isnt': '!='
+  , 'is not': '!='
+  , ':=': '?='
+};
+
+/**
+ * Units.
+ */
+
+var units = [
+    'em'
+  , 'ex'
+  , 'px'
+  , 'mm'
+  , 'cm'
+  , 'in'
+  , 'pt'
+  , 'pc'
+  , 'deg'
+  , 'rad'
+  , 'grad'
+  , 'ms'
+  , 's'
+  , 'Hz'
+  , 'kHz'
+  , 'rem'
+  , '%'].join('|');
+
+/**
+ * Unit RegExp.
+ */
+
+var unit = new RegExp('^(-)?(\\d+\\.\\d+|\\d+|\\.\\d+)(' + units + ')? *');
+
+/**
+ * Initialize a new `Lexer` with the given `str` and `options`.
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @api private
+ */
+
+var Lexer = module.exports = function Lexer(str, options) {
+  options = options || {};
+  this.str = str.replace(/\r\n?/g, '\n');
+  this.stash = [];
+  this.indentStack = [];
+  this.indentRe = null;
+  this.lineno = 1;
+};
+
+/**
+ * Lexer prototype.
+ */
+
+Lexer.prototype = {
+  
+  /**
+   * Custom inspect.
+   */
+  
+  inspect: function(){
+    var tok
+      , tmp = this.str
+      , buf = [];
+    while ('eos' != (tok = this.next()).type) {
+      buf.push(tok.inspect());
+    }
+    this.str = tmp;
+    this.prevIndents = 0;
+    return buf.concat(tok.inspect()).join('\n');
+  },
+
+  /**
+   * Lookahead `n` tokens.
+   *
+   * @param {Number} n
+   * @return {Object}
+   * @api private
+   */
+  
+  lookahead: function(n){
+    var fetch = n - this.stash.length;
+    while (fetch-- > 0) this.stash.push(this.advance());
+    return this.stash[--n];
+  },
+  
+  /**
+   * Consume the given `len`.
+   *
+   * @param {Number|Array} len
+   * @api private
+   */
+
+  skip: function(len){
+    this.str = this.str.substr(Array.isArray(len)
+      ? len[0].length
+      : len);
+  },
+
+  /**
+   * Fetch next token including those stashed by peek.
+   *
+   * @return {Token}
+   * @api private
+   */
+
+  next: function() {
+    var tok = this.stashed() || this.advance();
+    switch (tok.type) {
+      case 'newline':
+      case 'indent':
+        ++this.lineno;
+        break;
+      case 'outdent':
+        if ('outdent' != this.prev.type) ++this.lineno;
+    }
+    this.prev = tok;
+    tok.lineno = this.lineno;
+    return tok;
+  },
+
+  /**
+   * Fetch next token.
+   *
+   * @return {Token}
+   * @api private
+   */
+
+  advance: function() {
+    return this.eos()
+      || this.null()
+      || this.sep()
+      || this.keyword()
+      || this.urlchars()
+      || this.atrule()
+      || this.media()
+      || this.comment()
+      || this.newline()
+      || this.escaped()
+      || this.important()
+      || this.literal()
+      || this.function()
+      || this.brace()
+      || this.paren()
+      || this.color()
+      || this.string()
+      || this.unit()
+      || this.namedop()
+      || this.boolean()
+      || this.ident()
+      || this.op()
+      || this.space()
+      || this.selector();
+  },
+
+  /**
+   * Lookahead a single token.
+   *
+   * @return {Token}
+   * @api private
+   */
+  
+  peek: function() {
+    return this.lookahead(1);
+  },
+  
+  /**
+   * Return the next possibly stashed token.
+   *
+   * @return {Token}
+   * @api private
+   */
+
+  stashed: function() {
+    return this.stash.shift();
+  },
+
+  /**
+   * EOS | trailing outdents.
+   */
+
+  eos: function() {
+    if (this.str.length) return;
+    if (this.indentStack.length) {
+      this.indentStack.shift();
+      return new Token('outdent');
+    } else {
+      return new Token('eos');
+    }
+  },
+
+  /**
+   * url char
+   */
+
+  urlchars: function() {
+    var captures;
+    if (!this.isURL) return;
+    if (captures = /^[\/:@.;?&=*!,<>#%0-9]+/.exec(this.str)) {
+      this.skip(captures);
+      return new Token('literal', new nodes.Literal(captures[0]));
+    }
+  },
+
+  /**
+   * ';' ' '*
+   */
+
+  sep: function() {
+    var captures;
+    if (captures = /^; */.exec(this.str)) {
+      this.skip(captures);
+      return new Token(';');
+    }
+  },
+  
+  /**
+   * ' '+
+   */
+
+  space: function() {
+    var captures;
+    if (captures = /^( +)/.exec(this.str)) {
+      this.skip(captures);
+      return new Token('space');
+    }
+  },
+  
+  /**
+   * '\\' . ' '*
+   */
+   
+  escaped: function() {
+    var captures;
+    if (captures = /^\\(.) */.exec(this.str)) {
+      var c = captures[1];
+      this.skip(captures);
+      return new Token('ident', new nodes.Literal(c));
+    }
+  },
+  
+  /**
+   * '@css' ' '* '{' .* '}' ' '*
+   */
+  
+  literal: function() {
+    // HACK attack !!!
+    var captures;
+    if (captures = /^@css *\{/.exec(this.str)) {
+      this.skip(captures);
+      var c
+        , braces = 1
+        , css = '';
+      while (c = this.str[0]) {
+        this.str = this.str.substr(1);
+        switch (c) {
+          case '{': ++braces; break;
+          case '}': --braces; break;
+        }
+        css += c;
+        if (!braces) break;
+      }
+      css = css.replace(/\s*}$/, '');
+      return new Token('literal', new nodes.Literal(css));
+    }
+  },
+  
+  /**
+   * '!important' ' '*
+   */
+  
+  important: function() {
+    var captures;
+    if (captures = /^!important */.exec(this.str)) {
+      this.skip(captures);
+      return new Token('ident', new nodes.Literal('!important'));
+    }
+  },
+  
+  /**
+   * '{' | '}'
+   */
+  
+  brace: function() {
+    var captures;
+    if (captures = /^([{}])/.exec(this.str)) {
+      this.skip(1);
+      var brace = captures[1];
+      return new Token(brace, brace);
+    }
+  },
+  
+  /**
+   * '(' | ')' ' '*
+   */
+  
+  paren: function() {
+    var captures;
+    if (captures = /^([()]) */.exec(this.str)) {
+      var paren = captures[1];
+      this.skip(captures);
+      if (')' == paren) this.isURL = false;
+      return new Token(paren, paren);
+    }
+  },
+  
+  /**
+   * 'null'
+   */
+  
+  null: function() {
+    var captures;
+    if (captures = /^(null)\b */.exec(this.str)) {
+      this.skip(captures);
+      return new Token('null', nodes.null);
+    }
+  },
+  
+  /**
+   *   'if'
+   * | 'else'
+   * | 'unless'
+   * | 'return'
+   * | 'for'
+   * | 'in'
+   */
+  
+  keyword: function() {
+    var captures;
+    if (captures = /^(return|if|else|unless|for|in)\b */.exec(this.str)) {
+      var keyword = captures[1];
+      this.skip(captures);
+      return new Token(keyword, keyword);
+    }
+  },
+  
+  /**
+   *   'not'
+   * | 'and'
+   * | 'or'
+   * | 'is'
+   * | 'is not'
+   * | 'isnt'
+   * | 'is a'
+   * | 'is defined'
+   */
+  
+  namedop: function() {
+    var captures;
+    if (captures = /^(not|and|or|is a|is defined|isnt|is not|is)\b( *)/.exec(this.str)) {
+      var op = captures[1];
+      this.skip(captures);
+      op = alias[op] || op;
+      var tok = new Token(op, op);
+      tok.space = captures[2];
+      return tok;
+    }
+  },
+  
+  /**
+   *   ','
+   * | '+'
+   * | '+='
+   * | '-'
+   * | '-='
+   * | '*'
+   * | '*='
+   * | '/'
+   * | '/='
+   * | '%'
+   * | '%='
+   * | '**'
+   * | '!'
+   * | '&'
+   * | '&&'
+   * | '||'
+   * | '>'
+   * | '>='
+   * | '<'
+   * | '<='
+   * | '='
+   * | '=='
+   * | '!='
+   * | '!'
+   * | '~'
+   * | '?='
+   * | ':='
+   * | '?'
+   * | ':'
+   * | '['
+   * | ']'
+   * | '..'
+   * | '...'
+   */
+  
+  op: function() {
+    var captures;
+    if (captures = /^([.]{2,3}|&&|\|\||[!<>=?:]=|\*\*|[-+*\/%]=?|[,=?:!~<>&\[\]])( *)/.exec(this.str)) {
+      var op = captures[1];
+      this.skip(captures);
+      op = alias[op] || op;
+      var tok = new Token(op, op);
+      tok.space = captures[2];
+      return tok;
+    }
+  },
+
+  /**
+   * '@media' ([^{\n]+)
+   */
+  
+  media: function() {
+    var captures;
+    if (captures = /^@media *([^{\n]+)/.exec(this.str)) {
+      this.skip(captures);
+      return new Token('media', captures[1].trim());
+    }
+  },
+  
+  /**
+   * '@' ('import' | 'keyframes' | 'charset' | 'page' | 'font-face')
+   */
+  
+  atrule: function() {
+    var captures;
+    if (captures = /^@(import|(?:-(\w+)-)?keyframes|charset|font-face|page) */.exec(this.str)) {
+      this.skip(captures);
+      var vendor = captures[2]
+        , type = captures[1];
+      if (vendor) type = 'keyframes';
+      return new Token(type, vendor);
+    }
+  },
+
+  /**
+   * '//' *
+   */
+  
+  comment: function() {
+    // Single line
+    if ('/' == this.str[0] && '/' == this.str[1]) {
+      var end = this.str.indexOf('\n');
+      if (-1 == end) end = this.str.length;
+      this.skip(end);
+      return this.advance();
+    }
+
+    // Multi-line
+    if ('/' == this.str[0] && '*' == this.str[1]) {
+      var end = this.str.indexOf('*/');
+      if (-1 == end) end = this.str.length;
+      var str = this.str.substr(0, end + 2)
+        , lines = str.split('\n').length - 1
+        , suppress = true;
+      this.lineno += lines;
+      this.skip(end + 2);
+      // output
+      if ('!' == str[2]) {
+        str = str.replace('*!', '*');
+        suppress = false;
+      }
+      return new Token('comment', new nodes.Comment(str, suppress));
+    }
+  },
+
+  /**
+   * 'true' | 'false'
+   */
+  
+  boolean: function() {
+    var captures;
+    if (captures = /^(true|false)\b( *)/.exec(this.str)) {
+      var val = nodes.Boolean('true' == captures[1]);
+      this.skip(captures);
+      var tok = new Token('boolean', val);
+      tok.space = captures[2];
+      return tok;
+    }
+  },
+
+  /**
+   * -?[a-zA-Z$] [-\w\d$]* '('
+   */
+  
+  function: function() {
+    var captures;
+    if (captures = /^(-?[a-zA-Z$][-\w\d$]*)\(( *)/.exec(this.str)) {
+      var name = captures[1];
+      this.skip(captures);
+      this.isURL = 'url' == name;
+      var tok = new Token('function', new nodes.Ident(name));
+      tok.space = captures[2];
+      return tok;
+    } 
+  },
+
+  /**
+   * -?[_a-zA-Z$] [-\w\d$]*
+   */
+  
+  ident: function() {
+    var captures;
+    if (captures = /^(@)?(-?[_a-zA-Z$][-\w\d$]*)/.exec(this.str)) {
+      var at = captures[1]
+        , name = captures[2]
+        , id = new nodes.Ident(name);
+      this.skip(captures);
+      id.property = !! at;
+      return new Token('ident', id);
+    }
+  },
+  
+  /**
+   * '\n' ' '+
+   */
+
+  newline: function() {
+    var captures, re;
+
+    // we have established the indentation regexp
+    if (this.indentRe){
+      captures = this.indentRe.exec(this.str);
+    // figure out if we are using tabs or spaces
+    } else {
+      // try tabs
+      re = /^\n([\t]*) */;
+      captures = re.exec(this.str);
+
+      // nope, try spaces
+      if (captures && !captures[1].length) {
+        re = /^\n( *)/;
+        captures = re.exec(this.str);
+      }
+
+      // established
+      if (captures && captures[1].length) this.indentRe = re;
+    }
+
+
+    if (captures) {
+      var tok
+        , indents = captures[1].length;
+
+      this.skip(captures);
+      if (this.str[0] === ' ' || this.str[0] === '\t') {
+        throw new errors.SyntaxError('Invalid indentation. You can use tabs or spaces to indent, but not both.');
+      }
+
+      // Reset state
+      this.isVariable = false;
+
+      // Blank line
+      if ('\n' == this.str[0]) {
+        ++this.lineno;
+        return this.advance();
+      }
+
+      // Outdent
+      if (this.indentStack.length && indents < this.indentStack[0]) {
+        while (this.indentStack.length && this.indentStack[0] > indents) {
+          this.stash.push(new Token('outdent'));
+          this.indentStack.shift();
+        }
+        tok = this.stash.pop();
+      // Indent
+      } else if (indents && indents != this.indentStack[0]) {
+        this.indentStack.unshift(indents);
+        tok = new Token('indent');
+      // Newline
+      } else {
+        tok = new Token('newline');
+      }
+
+      return tok;
+    }
+  },
+
+  /**
+   * '-'? (digit+ | digit* '.' digit+) unit
+   */
+
+  unit: function() {
+    var captures;
+    if (captures = unit.exec(this.str)) {
+      this.skip(captures);
+      var n = parseFloat(captures[2]);
+      if ('-' == captures[1]) n = -n;
+      var node = new nodes.Unit(n, captures[3]);
+      return new Token('unit', node);
+    }
+  },
+
+  /**
+   * '"' [^"]+ '"' | "'"" [^']+ "'"
+   */
+
+  string: function() {
+    var captures;
+    if (captures = /^("[^"]*"|'[^']*') */.exec(this.str)) {
+      var str = captures[1];
+      this.skip(captures);
+      str = str.slice(1,-1).replace(/\\n/g, '\n');
+      return new Token('string', new nodes.String(str));
+    }
+  },
+
+  /**
+   * #rrggbbaa | #rrggbb | #rgba | #rgb
+   */
+
+  color: function() {
+		return this.rrggbbaa()
+			|| this.rrggbb()
+			|| this.rgba()
+			|| this.rgb()
+  },
+  
+  /**
+   * #rgb
+   */
+  
+  rgb: function() {
+    var captures;
+    if (captures = /^#([a-fA-F0-9]{3}) */.exec(this.str)) {
+      this.skip(captures);
+      var rgb = captures[1]
+        , r = parseInt(rgb[0] + rgb[0], 16)
+        , g = parseInt(rgb[1] + rgb[1], 16)
+        , b = parseInt(rgb[2] + rgb[2], 16)
+        , color = new nodes.RGBA(r, g, b, 1);
+      color.raw = captures[0];
+      return new Token('color', color); 
+    }
+  },
+  
+  /**
+   * #rgba
+   */
+  
+  rgba: function() {
+    var captures;
+    if (captures = /^#([a-fA-F0-9]{4}) */.exec(this.str)) {
+      this.skip(captures);
+      var rgb = captures[1]
+        , r = parseInt(rgb[0] + rgb[0], 16)
+        , g = parseInt(rgb[1] + rgb[1], 16)
+        , b = parseInt(rgb[2] + rgb[2], 16)
+        , a = parseInt(rgb[3] + rgb[3], 16)
+        , color = new nodes.RGBA(r, g, b, a/255);
+      color.raw = captures[0];
+      return new Token('color', color); 
+    }
+  },
+  
+  /**
+   * #rrggbb
+   */
+  
+  rrggbb: function() {
+    var captures;
+    if (captures = /^#([a-fA-F0-9]{6}) */.exec(this.str)) {
+      this.skip(captures);
+      var rgb = captures[1]
+        , r = parseInt(rgb.substr(0, 2), 16)
+        , g = parseInt(rgb.substr(2, 2), 16)
+        , b = parseInt(rgb.substr(4, 2), 16)
+        , color = new nodes.RGBA(r, g, b, 1);
+      color.raw = captures[0];
+      return new Token('color', color); 
+    }
+  },
+  
+  /**
+   * #rrggbbaa
+   */
+  
+  rrggbbaa: function() {
+    var captures;
+    if (captures = /^#([a-fA-F0-9]{8}) */.exec(this.str)) {
+      this.skip(captures);
+      var rgb = captures[1]
+        , r = parseInt(rgb.substr(0, 2), 16)
+        , g = parseInt(rgb.substr(2, 2), 16)
+        , b = parseInt(rgb.substr(4, 2), 16)
+        , a = parseInt(rgb.substr(6, 2), 16)
+        , color = new nodes.RGBA(r, g, b, a/255);
+      color.raw = captures[0];
+      return new Token('color', color); 
+    }
+  },
+  
+  /**
+   * [^\n,;]+
+   */
+  
+  selector: function() {
+    var captures;
+    if (captures = /^[^{\n,]+/.exec(this.str)) {
+      var selector = captures[0];
+      this.skip(captures);
+      return new Token('selector', selector);
+    }
+  }
+};