if (
  Function.prototype.name === undefined &&
  Object.defineProperty !== undefined
) {
  Object.defineProperty(Function.prototype, 'name', {
    get: function() {
      var regex = /function\s([^(]{1,})\(/,
        match = regex.exec(this.toString());
      return match && match.length > 1 ? match[1].trim() : '';
    },
  });
}
if (String.prototype.trimRight === undefined) {
  String.prototype.trimRight = function() {
    return String(this).replace(/\s+$/, '');
  };
}
var stylus = (function() {
  function require(p) {
    var path = require.resolve(p),
      mod = require.modules[path];
    if (!mod) throw new Error('failed to require "' + p + '"');
    if (!mod.exports) {
      mod.exports = {};
      mod.call(mod.exports, mod, mod.exports, require.relative(path));
    }
    return mod.exports;
  }
  var bifs =
    "called-from = ()\n\nvendors = moz webkit o ms official\n\n// stringify the given arg\n\n-string(arg)\n  type(arg) + ' ' + arg\n\n// require a color\n\nrequire-color(color)\n  unless color is a 'color'\n    error('RGB or HSL value expected, got a ' + -string(color))\n\n// require a unit\n\nrequire-unit(n)\n  unless n is a 'unit'\n    error('unit expected, got a ' + -string(n))\n\n// require a string\n\nrequire-string(str)\n  unless str is a 'string' or str is a 'ident'\n    error('string expected, got a ' + -string(str))\n\n// Math functions\n\nabs(n) { math(n, 'abs') }\nmin(a, b) { a < b ? a : b }\nmax(a, b) { a > b ? a : b }\n\n// Trigonometrics\nPI = -math-prop('PI')\n\nradians-to-degrees(angle)\n  angle * (180 / PI)\n\ndegrees-to-radians(angle)\n  unit(angle * (PI / 180),'')\n\nsin(n)\n  n = degrees-to-radians(n) if unit(n) == 'deg'\n  round(math(n, 'sin'), 9)\n\ncos(n)\n  n = degrees-to-radians(n) if unit(n) == 'deg'\n  round(math(n, 'cos'), 9)\n\n// Rounding Math functions\n\nceil(n, precision = 0)\n  multiplier = 10 ** precision\n  math(n * multiplier, 'ceil') / multiplier\n\nfloor(n, precision = 0)\n  multiplier = 10 ** precision\n  math(n * multiplier, 'floor') / multiplier\n\nround(n, precision = 0)\n  multiplier = 10 ** precision\n  math(n * multiplier, 'round') / multiplier\n\n// return the sum of the given numbers\n\nsum(nums)\n  sum = 0\n  sum += n for n in nums\n\n// return the average of the given numbers\n\navg(nums)\n  sum(nums) / length(nums)\n\n// return a unitless number, or pass through\n\nremove-unit(n)\n  if typeof(n) is 'unit'\n    unit(n, '')\n  else\n    n\n\n// convert a percent to a decimal, or pass through\n\npercent-to-decimal(n)\n  if unit(n) is '%'\n    remove-unit(n) / 100\n  else\n    n\n\n// check if n is an odd number\n\nodd(n)\n  1 == n % 2\n\n// check if n is an even number\n\neven(n)\n  0 == n % 2\n\n// check if color is light\n\nlight(color)\n  lightness(color) >= 50%\n\n// check if color is dark\n\ndark(color)\n  lightness(color) < 50%\n\n// desaturate color by amount\n\ndesaturate(color, amount)\n  adjust(color, 'saturation', - amount)\n\n// saturate color by amount\n\nsaturate(color = '', amount = 100%)\n  if color is a 'color'\n    adjust(color, 'saturation', amount)\n  else\n    unquote( 'saturate(' + color + ')' )\n\n// darken by the given amount\n\ndarken(color, amount)\n  adjust(color, 'lightness', - amount)\n\n// lighten by the given amount\n\nlighten(color, amount)\n  adjust(color, 'lightness', amount)\n\n// decrease opacity by amount\n\nfade-out(color, amount)\n  color - rgba(black, percent-to-decimal(amount))\n\n// increase opacity by amount\n\nfade-in(color, amount)\n  color + rgba(black, percent-to-decimal(amount))\n\n// spin hue by a given amount\n\nspin(color, amount)\n  color + unit(amount, deg)\n\n// mix two colors by a given amount\n\nmix(color1, color2, weight = 50%)\n  unless weight in 0..100\n    error('Weight must be between 0% and 100%')\n\n  if length(color1) == 2\n    weight = color1[0]\n    color1 = color1[1]\n\n  else if length(color2) == 2\n    weight = 100 - color2[0]\n    color2 = color2[1]\n\n  require-color(color1)\n  require-color(color2)\n\n  p = unit(weight / 100, '')\n  w = p * 2 - 1\n\n  a = alpha(color1) - alpha(color2)\n\n  w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2\n  w2 = 1 - w1\n\n  channels = (red(color1) red(color2)) (green(color1) green(color2)) (blue(color1) blue(color2))\n  rgb = ()\n\n  for pair in channels\n    push(rgb, floor(pair[0] * w1 + pair[1] * w2))\n\n  a1 = alpha(color1) * p\n  a2 = alpha(color2) * (1 - p)\n  alpha = a1 + a2\n\n  rgba(rgb[0], rgb[1], rgb[2], alpha)\n\n// invert colors, leave alpha intact\n\ninvert(color = '')\n  if color is a 'color'\n    rgba(#fff - color, alpha(color))\n  else\n    unquote( 'invert(' + color + ')' )\n\n// give complement of the given color\n\ncomplement( color )\n  spin( color, 180 )\n\n// give grayscale of the given color\n\ngrayscale( color = '' )\n  if color is a 'color'\n    desaturate( color, 100% )\n  else\n    unquote( 'grayscale(' + color + ')' )\n\n// mix the given color with white\n\ntint( color, percent )\n  mix( white, color, percent )\n\n// mix the given color with black\n\nshade( color, percent )\n  mix( black, color, percent )\n\n// return the last value in the given expr\n\nlast(expr)\n  expr[length(expr) - 1]\n\n// return keys in the given pairs or object\n\nkeys(pairs)\n  ret = ()\n  if type(pairs) == 'object'\n    for key in pairs\n      push(ret, key)\n  else\n    for pair in pairs\n      push(ret, pair[0]);\n  ret\n\n// return values in the given pairs or object\n\nvalues(pairs)\n  ret = ()\n  if type(pairs) == 'object'\n    for key, val in pairs\n      push(ret, val)\n  else\n    for pair in pairs\n      push(ret, pair[1]);\n  ret\n\n// join values with the given delimiter\n\njoin(delim, vals...)\n  buf = ''\n  vals = vals[0] if length(vals) == 1\n  for val, i in vals\n    buf += i ? delim + val : val\n\n// add a CSS rule to the containing block\n\n// - This definition allows add-property to be used as a mixin\n// - It has the same effect as interpolation but allows users\n//   to opt for a functional style\n\nadd-property-function = add-property\nadd-property(name, expr)\n  if mixin\n    {name} expr\n  else\n    add-property-function(name, expr)\n\nprefix-classes(prefix)\n  -prefix-classes(prefix, block)\n\n// Caching mixin, use inside your functions to enable caching by extending.\n\n$stylus_mixin_cache = {}\ncache()\n  $key = (current-media() or 'no-media') + '__' + called-from[0] + '__' + arguments\n  if $key in $stylus_mixin_cache\n    @extend {'$cache_placeholder_for_' + $stylus_mixin_cache[$key]}\n  else if 'cache' in called-from\n    {block}\n  else\n    $id = length($stylus_mixin_cache)\n\n    &,\n    /$cache_placeholder_for_{$id}\n      $stylus_mixin_cache[$key] = $id\n      {block}\n\n// Percentage function to convert a number, e.g. '.45', into a percentage, e.g. '45%'\n\npercentage(num)\n  return unit(num * 100, '%')\n\n// Returns the position of a `value` within a `list`\n\nindex(list, value)\n  for val, i in list\n    return i if val == value\n";
  require.modules = {};
  require.resolve = function(path) {
    var orig = path,
      reg = path + '.js',
      index = path + '/index.js';
    return (
      (require.modules[reg] && reg) || (require.modules[index] && index) || orig
    );
  };
  require.register = function(path, fn) {
    require.modules[path] = fn;
  };
  require.relative = function(parent) {
    return function(p) {
      if ('.' != p[0]) return require(p);
      var path = parent.split('/'),
        segs = p.split('/');
      path.pop();
      for (var i = 0; i < segs.length; i++) {
        var seg = segs[i];
        if ('..' == seg) path.pop();
        else if ('.' != seg) path.push(seg);
      }
      return require(path.join('/'));
    };
  };
  require.register('path.js', function(module, exports, require) {
    var isWindows = false;
    function normalizeArray(parts, allowAboveRoot) {
      var up = 0;
      for (var i = parts.length - 1; i >= 0; i--) {
        var last = parts[i];
        if (last == '.') {
          parts.splice(i, 1);
        } else if (last === '..') {
          parts.splice(i, 1);
          up++;
        } else if (up) {
          parts.splice(i, 1);
          up--;
        }
      }
      if (allowAboveRoot) {
        for (; up--; up) {
          parts.unshift('..');
        }
      }
      return parts;
    }
    var splitPathRe = /^([\s\S]+\/(?!$)|\/)?((?:[\s\S]+?)?(\.[^.]*)?)$/;
    exports.normalize = function(path) {
      var isAbsolute = path.charAt(0) === '/',
        trailingSlash = path.slice(-1) === '/';
      path = normalizeArray(
        path.split('/').filter(function(p) {
          return !!p;
        }),
        !isAbsolute,
      ).join('/');
      if (!path && !isAbsolute) {
        path = '.';
      }
      if (path && trailingSlash) {
        path += '/';
      }
      return (isAbsolute ? '/' : '') + path;
    };
    exports.join = function() {
      var paths = Array.prototype.slice.call(arguments, 0);
      return exports.normalize(
        paths
          .filter(function(p, index) {
            return p && typeof p === 'string';
          })
          .join('/'),
      );
    };
    exports.relative = function(from, to) {
      from = exports.resolve(from).substr(1);
      to = exports.resolve(to).substr(1);
      function trim(arr) {
        var start = 0;
        for (; start < arr.length; start++) {
          if (arr[start] !== '') break;
        }
        var end = arr.length - 1;
        for (; end >= 0; end--) {
          if (arr[end] !== '') break;
        }
        if (start > end) return [];
        return arr.slice(start, end - start + 1);
      }
      var fromParts = trim(from.split('/'));
      var toParts = trim(to.split('/'));
      var length = Math.min(fromParts.length, toParts.length);
      var samePartsLength = length;
      for (var i = 0; i < length; i++) {
        if (fromParts[i] !== toParts[i]) {
          samePartsLength = i;
          break;
        }
      }
      var outputParts = [];
      for (var i = samePartsLength; i < fromParts.length; i++) {
        outputParts.push('..');
      }
      outputParts = outputParts.concat(toParts.slice(samePartsLength));
      return outputParts.join('/');
    };
    exports.dirname = function(path) {
      var dir = splitPathRe.exec(path)[1] || '';
      if (!dir) {
        return '.';
      } else if (
        dir.length === 1 ||
        (isWindows && dir.length <= 3 && dir.charAt(1) === ':')
      ) {
        return dir;
      } else {
        return dir.substring(0, dir.length - 1);
      }
    };
    exports.basename = function(path, ext) {
      var f = splitPathRe.exec(path)[2] || '';
      if (ext && f.substr(-1 * ext.length) === ext) {
        f = f.substr(0, f.length - ext.length);
      }
      return f;
    };
    exports.extname = function(path) {
      return splitPathRe.exec(path)[3] || '';
    };
  });
  require.register('colors.js', function(module, exports, require) {
    module.exports = {
      aliceblue: [240, 248, 255, 1],
      antiquewhite: [250, 235, 215, 1],
      aqua: [0, 255, 255, 1],
      aquamarine: [127, 255, 212, 1],
      azure: [240, 255, 255, 1],
      beige: [245, 245, 220, 1],
      bisque: [255, 228, 196, 1],
      black: [0, 0, 0, 1],
      blanchedalmond: [255, 235, 205, 1],
      blue: [0, 0, 255, 1],
      blueviolet: [138, 43, 226, 1],
      brown: [165, 42, 42, 1],
      burlywood: [222, 184, 135, 1],
      cadetblue: [95, 158, 160, 1],
      chartreuse: [127, 255, 0, 1],
      chocolate: [210, 105, 30, 1],
      coral: [255, 127, 80, 1],
      cornflowerblue: [100, 149, 237, 1],
      cornsilk: [255, 248, 220, 1],
      crimson: [220, 20, 60, 1],
      cyan: [0, 255, 255, 1],
      darkblue: [0, 0, 139, 1],
      darkcyan: [0, 139, 139, 1],
      darkgoldenrod: [184, 134, 11, 1],
      darkgray: [169, 169, 169, 1],
      darkgreen: [0, 100, 0, 1],
      darkgrey: [169, 169, 169, 1],
      darkkhaki: [189, 183, 107, 1],
      darkmagenta: [139, 0, 139, 1],
      darkolivegreen: [85, 107, 47, 1],
      darkorange: [255, 140, 0, 1],
      darkorchid: [153, 50, 204, 1],
      darkred: [139, 0, 0, 1],
      darksalmon: [233, 150, 122, 1],
      darkseagreen: [143, 188, 143, 1],
      darkslateblue: [72, 61, 139, 1],
      darkslategray: [47, 79, 79, 1],
      darkslategrey: [47, 79, 79, 1],
      darkturquoise: [0, 206, 209, 1],
      darkviolet: [148, 0, 211, 1],
      deeppink: [255, 20, 147, 1],
      deepskyblue: [0, 191, 255, 1],
      dimgray: [105, 105, 105, 1],
      dimgrey: [105, 105, 105, 1],
      dodgerblue: [30, 144, 255, 1],
      firebrick: [178, 34, 34, 1],
      floralwhite: [255, 250, 240, 1],
      forestgreen: [34, 139, 34, 1],
      fuchsia: [255, 0, 255, 1],
      gainsboro: [220, 220, 220, 1],
      ghostwhite: [248, 248, 255, 1],
      gold: [255, 215, 0, 1],
      goldenrod: [218, 165, 32, 1],
      gray: [128, 128, 128, 1],
      green: [0, 128, 0, 1],
      greenyellow: [173, 255, 47, 1],
      grey: [128, 128, 128, 1],
      honeydew: [240, 255, 240, 1],
      hotpink: [255, 105, 180, 1],
      indianred: [205, 92, 92, 1],
      indigo: [75, 0, 130, 1],
      ivory: [255, 255, 240, 1],
      khaki: [240, 230, 140, 1],
      lavender: [230, 230, 250, 1],
      lavenderblush: [255, 240, 245, 1],
      lawngreen: [124, 252, 0, 1],
      lemonchiffon: [255, 250, 205, 1],
      lightblue: [173, 216, 230, 1],
      lightcoral: [240, 128, 128, 1],
      lightcyan: [224, 255, 255, 1],
      lightgoldenrodyellow: [250, 250, 210, 1],
      lightgray: [211, 211, 211, 1],
      lightgreen: [144, 238, 144, 1],
      lightgrey: [211, 211, 211, 1],
      lightpink: [255, 182, 193, 1],
      lightsalmon: [255, 160, 122, 1],
      lightseagreen: [32, 178, 170, 1],
      lightskyblue: [135, 206, 250, 1],
      lightslategray: [119, 136, 153, 1],
      lightslategrey: [119, 136, 153, 1],
      lightsteelblue: [176, 196, 222, 1],
      lightyellow: [255, 255, 224, 1],
      lime: [0, 255, 0, 1],
      limegreen: [50, 205, 50, 1],
      linen: [250, 240, 230, 1],
      magenta: [255, 0, 255, 1],
      maroon: [128, 0, 0, 1],
      mediumaquamarine: [102, 205, 170, 1],
      mediumblue: [0, 0, 205, 1],
      mediumorchid: [186, 85, 211, 1],
      mediumpurple: [147, 112, 219, 1],
      mediumseagreen: [60, 179, 113, 1],
      mediumslateblue: [123, 104, 238, 1],
      mediumspringgreen: [0, 250, 154, 1],
      mediumturquoise: [72, 209, 204, 1],
      mediumvioletred: [199, 21, 133, 1],
      midnightblue: [25, 25, 112, 1],
      mintcream: [245, 255, 250, 1],
      mistyrose: [255, 228, 225, 1],
      moccasin: [255, 228, 181, 1],
      navajowhite: [255, 222, 173, 1],
      navy: [0, 0, 128, 1],
      oldlace: [253, 245, 230, 1],
      olive: [128, 128, 0, 1],
      olivedrab: [107, 142, 35, 1],
      orange: [255, 165, 0, 1],
      orangered: [255, 69, 0, 1],
      orchid: [218, 112, 214, 1],
      palegoldenrod: [238, 232, 170, 1],
      palegreen: [152, 251, 152, 1],
      paleturquoise: [175, 238, 238, 1],
      palevioletred: [219, 112, 147, 1],
      papayawhip: [255, 239, 213, 1],
      peachpuff: [255, 218, 185, 1],
      peru: [205, 133, 63, 1],
      pink: [255, 192, 203, 1],
      plum: [221, 160, 221, 1],
      powderblue: [176, 224, 230, 1],
      purple: [128, 0, 128, 1],
      red: [255, 0, 0, 1],
      rosybrown: [188, 143, 143, 1],
      royalblue: [65, 105, 225, 1],
      saddlebrown: [139, 69, 19, 1],
      salmon: [250, 128, 114, 1],
      sandybrown: [244, 164, 96, 1],
      seagreen: [46, 139, 87, 1],
      seashell: [255, 245, 238, 1],
      sienna: [160, 82, 45, 1],
      silver: [192, 192, 192, 1],
      skyblue: [135, 206, 235, 1],
      slateblue: [106, 90, 205, 1],
      slategray: [112, 128, 144, 1],
      slategrey: [112, 128, 144, 1],
      snow: [255, 250, 250, 1],
      springgreen: [0, 255, 127, 1],
      steelblue: [70, 130, 180, 1],
      tan: [210, 180, 140, 1],
      teal: [0, 128, 128, 1],
      thistle: [216, 191, 216, 1],
      tomato: [255, 99, 71, 1],
      transparent: [0, 0, 0, 0],
      turquoise: [64, 224, 208, 1],
      violet: [238, 130, 238, 1],
      wheat: [245, 222, 179, 1],
      white: [255, 255, 255, 1],
      whitesmoke: [245, 245, 245, 1],
      yellow: [255, 255, 0, 1],
      yellowgreen: [154, 205, 50, 1],
      rebeccapurple: [102, 51, 153, 1],
    };
  });
  require.register('errors.js', function(module, exports, require) {
    exports.ParseError = ParseError;
    exports.SyntaxError = SyntaxError;
    SyntaxError.prototype.__proto__ = Error.prototype;
    function ParseError(msg) {
      this.name = 'ParseError';
      this.message = msg;
      Error.captureStackTrace(this, ParseError);
    }
    ParseError.prototype.__proto__ = Error.prototype;
    function SyntaxError(msg) {
      this.name = 'SyntaxError';
      this.message = msg;
      Error.captureStackTrace(this, ParseError);
    }
    SyntaxError.prototype.__proto__ = Error.prototype;
  });
  require.register('units.js', function(module, exports, require) {
    module.exports = [
      'em',
      'ex',
      'ch',
      'rem',
      'vw',
      'vh',
      'vmin',
      'vmax',
      'cm',
      'mm',
      'in',
      'pt',
      'pc',
      'px',
      'deg',
      'grad',
      'rad',
      'turn',
      's',
      'ms',
      'Hz',
      'kHz',
      'dpi',
      'dpcm',
      'dppx',
      'x',
      '%',
      'fr',
    ];
  });
  require.register('functions/index.js', function(module, exports, require) {
    exports['add-property'] = require('./add-property');
    exports.adjust = require('./adjust');
    exports.alpha = require('./alpha');
    exports['base-convert'] = require('./base-convert');
    exports.basename = require('./basename');
    exports.blend = require('./blend');
    exports.blue = require('./blue');
    exports.clone = require('./clone');
    exports.component = require('./component');
    exports.contrast = require('./contrast');
    exports.convert = require('./convert');
    exports['current-media'] = require('./current-media');
    exports.define = require('./define');
    exports.dirname = require('./dirname');
    exports.error = require('./error');
    exports.extname = require('./extname');
    exports.green = require('./green');
    exports.hsl = require('./hsl');
    exports.hsla = require('./hsla');
    exports.hue = require('./hue');
    exports.length = require('./length');
    exports.lightness = require('./lightness');
    exports['list-separator'] = require('./list-separator');
    exports.lookup = require('./lookup');
    exports.luminosity = require('./luminosity');
    exports.match = require('./match');
    exports.math = require('./math');
    exports.merge = exports.extend = require('./merge');
    exports.operate = require('./operate');
    exports['opposite-position'] = require('./opposite-position');
    exports.p = require('./p');
    exports.pathjoin = require('./pathjoin');
    exports.pop = require('./pop');
    exports.push = exports.append = require('./push');
    exports.range = require('./range');
    exports.red = require('./red');
    exports.remove = require('./remove');
    exports.replace = require('./replace');
    exports.rgb = require('./rgb');
    exports.rgba = require('./rgba');
    exports.s = require('./s');
    exports.saturation = require('./saturation');
    exports['selector-exists'] = require('./selector-exists');
    exports.selector = require('./selector');
    exports.selectors = require('./selectors');
    exports.shift = require('./shift');
    exports.split = require('./split');
    exports.substr = require('./substr');
    exports.slice = require('./slice');
    exports.tan = require('./tan');
    exports.trace = require('./trace');
    exports.transparentify = require('./transparentify');
    exports.type = exports.typeof = exports['type-of'] = require('./type');
    exports.unit = require('./unit');
    exports.unquote = require('./unquote');
    exports.unshift = exports.prepend = require('./unshift');
    exports.warn = require('./warn');
    exports['-math-prop'] = require('./math-prop');
    exports['-prefix-classes'] = require('./prefix-classes');
  });
  require.register('functions/url.js', function(module, exports, require) {
    var Compiler = require('../visitor/compiler'),
      events = require('../renderer').events,
      nodes = require('../nodes'),
      extname = require('../path').extname,
      utils = require('../utils');
    var defaultMimes = {
      '.gif': 'image/gif',
      '.png': 'image/png',
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.svg': 'image/svg+xml',
      '.webp': 'image/webp',
      '.ttf': 'application/x-font-ttf',
      '.eot': 'application/vnd.ms-fontobject',
      '.woff': 'application/font-woff',
      '.woff2': 'application/font-woff2',
    };
    var encodingTypes = { BASE_64: 'base64', UTF8: 'charset=utf-8' };
    module.exports = function(options) {
      options = options || {};
      var _paths = options.paths || [];
      var sizeLimit = null != options.limit ? options.limit : 3e4;
      var mimes = options.mimes || defaultMimes;
      function fn(url, enc) {
        var compiler = new Compiler(url),
          encoding = encodingTypes.BASE_64;
        compiler.isURL = true;
        url = url.nodes
          .map(function(node) {
            return compiler.visit(node);
          })
          .join('');
        url = parse(url);
        var ext = extname(url.pathname),
          mime = mimes[ext],
          hash = url.hash || '',
          literal = new nodes.Literal('url("' + url.href + '")'),
          paths = _paths.concat(this.paths),
          buf,
          result;
        if (!mime) return literal;
        if (url.protocol) return literal;
        var found = utils.lookup(url.pathname, paths);
        if (!found) {
          events.emit(
            'file not found',
            'File ' + literal + ' could not be found, literal url retained!',
          );
          return literal;
        }
        buf = fs.readFileSync(found);
        if (false !== sizeLimit && buf.length > sizeLimit) return literal;
        if (enc && 'utf8' == enc.first.val.toLowerCase()) {
          encoding = encodingTypes.UTF8;
          result = buf
            .toString('utf8')
            .replace(/\s+/g, ' ')
            .replace(/[{}\|\\\^~\[\]`"<>#%]/g, function(match) {
              return '%' + match[0].charCodeAt(0).toString(16).toUpperCase();
            })
            .trim();
        } else {
          result = buf.toString(encoding) + hash;
        }
        return new nodes.Literal(
          'url("data:' + mime + ';' + encoding + ',' + result + '")',
        );
      }
      fn.raw = true;
      return fn;
    };
    module.exports.mimes = defaultMimes;
  });
  require.register('functions/add-property.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function addProperty(name, expr) {
      utils.assertType(name, 'expression', 'name');
      name = utils.unwrap(name).first;
      utils.assertString(name, 'name');
      utils.assertType(expr, 'expression', 'expr');
      var prop = new nodes.Property([name], expr);
      var block = this.closestBlock;
      var len = block.nodes.length,
        head = block.nodes.slice(0, block.index),
        tail = block.nodes.slice(block.index++, len);
      head.push(prop);
      block.nodes = head.concat(tail);
      return prop;
    }).raw = true;
  });
  require.register('functions/adjust.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function adjust(color, prop, amount) {
      utils.assertColor(color, 'color');
      utils.assertString(prop, 'prop');
      utils.assertType(amount, 'unit', 'amount');
      var hsl = color.hsla.clone();
      prop = { hue: 'h', saturation: 's', lightness: 'l' }[prop.string];
      if (!prop) throw new Error('invalid adjustment property');
      var val = amount.val;
      if ('%' == amount.type) {
        val =
          'l' == prop && val > 0
            ? (100 - hsl[prop]) * val / 100
            : hsl[prop] * (val / 100);
      }
      hsl[prop] += val;
      return hsl.rgba;
    };
  });
  require.register('functions/alpha.js', function(module, exports, require) {
    var nodes = require('../nodes'),
      rgba = require('./rgba');
    module.exports = function alpha(color, value) {
      color = color.rgba;
      if (value) {
        return rgba(
          new nodes.Unit(color.r),
          new nodes.Unit(color.g),
          new nodes.Unit(color.b),
          value,
        );
      }
      return new nodes.Unit(color.a, '');
    };
  });
  require.register('functions/base-convert.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function(num, base, width) {
      utils.assertPresent(num, 'number');
      utils.assertPresent(base, 'base');
      num = utils.unwrap(num).nodes[0].val;
      base = utils.unwrap(base).nodes[0].val;
      width = (width && utils.unwrap(width).nodes[0].val) || 2;
      var result = Number(num).toString(base);
      while (result.length < width) {
        result = '0' + result;
      }
      return new nodes.Literal(result);
    }).raw = true;
  });
  require.register('functions/basename.js', function(module, exports, require) {
    var utils = require('../utils'),
      path = require('../path');
    module.exports = function basename(p, ext) {
      utils.assertString(p, 'path');
      return path.basename(p.val, ext && ext.val);
    };
  });
  require.register('functions/blend.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function blend(top, bottom) {
      utils.assertColor(top);
      top = top.rgba;
      bottom = bottom || new nodes.RGBA(255, 255, 255, 1);
      utils.assertColor(bottom);
      bottom = bottom.rgba;
      return new nodes.RGBA(
        top.r * top.a + bottom.r * (1 - top.a),
        top.g * top.a + bottom.g * (1 - top.a),
        top.b * top.a + bottom.b * (1 - top.a),
        top.a + bottom.a - top.a * bottom.a,
      );
    };
  });
  require.register('functions/blue.js', function(module, exports, require) {
    var nodes = require('../nodes'),
      rgba = require('./rgba');
    module.exports = function blue(color, value) {
      color = color.rgba;
      if (value) {
        return rgba(
          new nodes.Unit(color.r),
          new nodes.Unit(color.g),
          value,
          new nodes.Unit(color.a),
        );
      }
      return new nodes.Unit(color.b, '');
    };
  });
  require.register('functions/clone.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function clone(expr) {
      utils.assertPresent(expr, 'expr');
      return expr.clone();
    }).raw = true;
  });
  require.register('functions/component.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    var componentMap = {
      red: 'r',
      green: 'g',
      blue: 'b',
      alpha: 'a',
      hue: 'h',
      saturation: 's',
      lightness: 'l',
    };
    var unitMap = { hue: 'deg', saturation: '%', lightness: '%' };
    var typeMap = {
      red: 'rgba',
      blue: 'rgba',
      green: 'rgba',
      alpha: 'rgba',
      hue: 'hsla',
      saturation: 'hsla',
      lightness: 'hsla',
    };
    module.exports = function component(color, name) {
      utils.assertColor(color, 'color');
      utils.assertString(name, 'name');
      var name = name.string,
        unit = unitMap[name],
        type = typeMap[name],
        name = componentMap[name];
      if (!name) throw new Error('invalid color component "' + name + '"');
      return new nodes.Unit(color[type][name], unit);
    };
  });
  require.register('functions/contrast.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes'),
      blend = require('./blend'),
      luminosity = require('./luminosity');
    module.exports = function contrast(top, bottom) {
      if ('rgba' != top.nodeName && 'hsla' != top.nodeName) {
        return new nodes.Literal(
          'contrast(' + (top.isNull ? '' : top.toString()) + ')',
        );
      }
      var result = new nodes.Object();
      top = top.rgba;
      bottom = bottom || new nodes.RGBA(255, 255, 255, 1);
      utils.assertColor(bottom);
      bottom = bottom.rgba;
      function contrast(top, bottom) {
        if (1 > top.a) {
          top = blend(top, bottom);
        }
        var l1 = luminosity(bottom).val + 0.05,
          l2 = luminosity(top).val + 0.05,
          ratio = l1 / l2;
        if (l2 > l1) {
          ratio = 1 / ratio;
        }
        return Math.round(ratio * 10) / 10;
      }
      if (1 <= bottom.a) {
        var resultRatio = new nodes.Unit(contrast(top, bottom));
        result.set('ratio', resultRatio);
        result.set('error', new nodes.Unit(0));
        result.set('min', resultRatio);
        result.set('max', resultRatio);
      } else {
        var onBlack = contrast(top, blend(bottom, new nodes.RGBA(0, 0, 0, 1))),
          onWhite = contrast(
            top,
            blend(bottom, new nodes.RGBA(255, 255, 255, 1)),
          ),
          max = Math.max(onBlack, onWhite);
        function processChannel(topChannel, bottomChannel) {
          return Math.min(
            Math.max(
              0,
              (topChannel - bottomChannel * bottom.a) / (1 - bottom.a),
            ),
            255,
          );
        }
        var closest = new nodes.RGBA(
          processChannel(top.r, bottom.r),
          processChannel(top.g, bottom.g),
          processChannel(top.b, bottom.b),
          1,
        );
        var min = contrast(top, blend(bottom, closest));
        result.set('ratio', new nodes.Unit(Math.round((min + max) * 50) / 100));
        result.set('error', new nodes.Unit(Math.round((max - min) * 50) / 100));
        result.set('min', new nodes.Unit(min));
        result.set('max', new nodes.Unit(max));
      }
      return result;
    };
  });
  require.register('functions/convert.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function convert(str) {
      utils.assertString(str, 'str');
      return utils.parseString(str.string);
    };
  });
  require.register('functions/current-media.js', function(
    module,
    exports,
    require,
  ) {
    var nodes = require('../nodes');
    module.exports = function currentMedia() {
      var self = this;
      return new nodes.String(lookForMedia(this.closestBlock.node) || '');
      function lookForMedia(node) {
        if ('media' == node.nodeName) {
          node.val = self.visit(node.val);
          return node.toString();
        } else if (node.block.parent.node) {
          return lookForMedia(node.block.parent.node);
        }
      }
    };
  });
  require.register('functions/define.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function define(name, expr, global) {
      utils.assertType(name, 'string', 'name');
      expr = utils.unwrap(expr);
      var scope = this.currentScope;
      if (global && global.toBoolean().isTrue) {
        scope = this.global.scope;
      }
      var node = new nodes.Ident(name.val, expr);
      scope.add(node);
      return nodes.nil;
    };
  });
  require.register('functions/dirname.js', function(module, exports, require) {
    var utils = require('../utils'),
      path = require('../path');
    module.exports = function dirname(p) {
      utils.assertString(p, 'path');
      return path.dirname(p.val).replace(/\\/g, '/');
    };
  });
  require.register('functions/error.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function error(msg) {
      utils.assertType(msg, 'string', 'msg');
      var err = new Error(msg.val);
      err.fromStylus = true;
      throw err;
    };
  });
  require.register('functions/extname.js', function(module, exports, require) {
    var utils = require('../utils'),
      path = require('../path');
    module.exports = function extname(p) {
      utils.assertString(p, 'path');
      return path.extname(p.val);
    };
  });
  require.register('functions/green.js', function(module, exports, require) {
    var nodes = require('../nodes'),
      rgba = require('./rgba');
    module.exports = function green(color, value) {
      color = color.rgba;
      if (value) {
        return rgba(
          new nodes.Unit(color.r),
          value,
          new nodes.Unit(color.b),
          new nodes.Unit(color.a),
        );
      }
      return new nodes.Unit(color.g, '');
    };
  });
  require.register('functions/hsl.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes'),
      hsla = require('./hsla');
    module.exports = function hsl(hue, saturation, lightness) {
      if (1 == arguments.length) {
        utils.assertColor(hue, 'color');
        return hue.hsla;
      } else {
        return hsla(hue, saturation, lightness, new nodes.Unit(1));
      }
    };
  });
  require.register('functions/hsla.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function hsla(hue, saturation, lightness, alpha) {
      switch (arguments.length) {
        case 1:
          utils.assertColor(hue);
          return hue.hsla;
        case 2:
          utils.assertColor(hue);
          var color = hue.hsla;
          utils.assertType(saturation, 'unit', 'alpha');
          var alpha = saturation.clone();
          if ('%' == alpha.type) alpha.val /= 100;
          return new nodes.HSLA(color.h, color.s, color.l, alpha.val);
        default:
          utils.assertType(hue, 'unit', 'hue');
          utils.assertType(saturation, 'unit', 'saturation');
          utils.assertType(lightness, 'unit', 'lightness');
          utils.assertType(alpha, 'unit', 'alpha');
          var alpha = alpha.clone();
          if (alpha && '%' == alpha.type) alpha.val /= 100;
          return new nodes.HSLA(
            hue.val,
            saturation.val,
            lightness.val,
            alpha.val,
          );
      }
    };
  });
  require.register('functions/hue.js', function(module, exports, require) {
    var nodes = require('../nodes'),
      hsla = require('./hsla'),
      component = require('./component');
    module.exports = function hue(color, value) {
      if (value) {
        var hslaColor = color.hsla;
        return hsla(
          value,
          new nodes.Unit(hslaColor.s),
          new nodes.Unit(hslaColor.l),
          new nodes.Unit(hslaColor.a),
        );
      }
      return component(color, new nodes.String('hue'));
    };
  });
  require.register('functions/length.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function length(expr) {
      if (expr) {
        if (expr.nodes) {
          var nodes = utils.unwrap(expr).nodes;
          if (1 == nodes.length && 'object' == nodes[0].nodeName) {
            return nodes[0].length;
          } else {
            return nodes.length;
          }
        } else {
          return 1;
        }
      }
      return 0;
    }).raw = true;
  });
  require.register('functions/lightness.js', function(
    module,
    exports,
    require,
  ) {
    var nodes = require('../nodes'),
      hsla = require('./hsla'),
      component = require('./component');
    module.exports = function lightness(color, value) {
      if (value) {
        var hslaColor = color.hsla;
        return hsla(
          new nodes.Unit(hslaColor.h),
          new nodes.Unit(hslaColor.s),
          value,
          new nodes.Unit(hslaColor.a),
        );
      }
      return component(color, new nodes.String('lightness'));
    };
  });
  require.register('functions/list-separator.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function listSeparator(list) {
      list = utils.unwrap(list);
      return new nodes.String(list.isList ? ',' : ' ');
    }).raw = true;
  });
  require.register('functions/lookup.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function lookup(name) {
      utils.assertType(name, 'string', 'name');
      var node = this.lookup(name.val);
      if (!node) return nodes.nil;
      return this.visit(node);
    };
  });
  require.register('functions/luminosity.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function luminosity(color) {
      utils.assertColor(color);
      color = color.rgba;
      function processChannel(channel) {
        channel = channel / 255;
        return 0.03928 > channel
          ? channel / 12.92
          : Math.pow((channel + 0.055) / 1.055, 2.4);
      }
      return new nodes.Unit(
        0.2126 * processChannel(color.r) +
          0.7152 * processChannel(color.g) +
          0.0722 * processChannel(color.b),
      );
    };
  });
  require.register('functions/match.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    var VALID_FLAGS = 'igm';
    module.exports = function match(pattern, val, flags) {
      utils.assertType(pattern, 'string', 'pattern');
      utils.assertString(val, 'val');
      var re = new RegExp(
        pattern.val,
        validateFlags(flags) ? flags.string : '',
      );
      return val.string.match(re);
    };
    function validateFlags(flags) {
      flags = flags && flags.string;
      if (flags) {
        return flags.split('').every(function(flag) {
          return ~VALID_FLAGS.indexOf(flag);
        });
      }
      return false;
    }
  });
  require.register('functions/math-prop.js', function(
    module,
    exports,
    require,
  ) {
    var nodes = require('../nodes');
    module.exports = function math(prop) {
      return new nodes.Unit(Math[prop.string]);
    };
  });
  require.register('functions/math.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function math(n, fn) {
      utils.assertType(n, 'unit', 'n');
      utils.assertString(fn, 'fn');
      return new nodes.Unit(Math[fn.string](n.val), n.type);
    };
  });
  require.register('functions/merge.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function merge(dest) {
      utils.assertPresent(dest, 'dest');
      dest = utils.unwrap(dest).first;
      utils.assertType(dest, 'object', 'dest');
      var last = utils.unwrap(arguments[arguments.length - 1]).first,
        deep = true === last.val;
      for (var i = 1, len = arguments.length - deep; i < len; ++i) {
        utils.merge(dest.vals, utils.unwrap(arguments[i]).first.vals, deep);
      }
      return dest;
    }).raw = true;
  });
  require.register('functions/operate.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function operate(op, left, right) {
      utils.assertType(op, 'string', 'op');
      utils.assertPresent(left, 'left');
      utils.assertPresent(right, 'right');
      return left.operate(op.val, right);
    };
  });
  require.register('functions/opposite-position.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function oppositePosition(positions) {
      var expr = [];
      utils.unwrap(positions).nodes.forEach(function(pos, i) {
        utils.assertString(pos, 'position ' + i);
        pos = (function() {
          switch (pos.string) {
            case 'top':
              return 'bottom';
            case 'bottom':
              return 'top';
            case 'left':
              return 'right';
            case 'right':
              return 'left';
            case 'center':
              return 'center';
            default:
              throw new Error('invalid position ' + pos);
          }
        })();
        expr.push(new nodes.Literal(pos));
      });
      return expr;
    }).raw = true;
  });
  require.register('functions/p.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function p() {
      [].slice.call(arguments).forEach(function(expr) {
        expr = utils.unwrap(expr);
        if (!expr.nodes.length) return;
        console.log(
          'inspect: %s',
          expr.toString().replace(/^\(|\)$/g, ''),
        );
      });
      return nodes.nil;
    }).raw = true;
  });
  require.register('functions/pathjoin.js', function(module, exports, require) {
    var path = require('../path');
    (module.exports = function pathjoin() {
      var paths = [].slice.call(arguments).map(function(path) {
        return path.first.string;
      });
      return path.join.apply(null, paths).replace(/\\/g, '/');
    }).raw = true;
  });
  require.register('functions/pop.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function pop(expr) {
      expr = utils.unwrap(expr);
      return expr.nodes.pop();
    }).raw = true;
  });
  require.register('functions/prefix-classes.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils');
    module.exports = function prefixClasses(prefix, block) {
      utils.assertString(prefix, 'prefix');
      utils.assertType(block, 'block', 'block');
      var _prefix = this.prefix;
      this.options.prefix = this.prefix = prefix.string;
      block = this.visit(block);
      this.options.prefix = this.prefix = _prefix;
      return block;
    };
  });
  require.register('functions/push.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function(expr) {
      expr = utils.unwrap(expr);
      for (var i = 1, len = arguments.length; i < len; ++i) {
        expr.nodes.push(utils.unwrap(arguments[i]).clone());
      }
      return expr.nodes.length;
    }).raw = true;
  });
  require.register('functions/range.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function range(start, stop, step) {
      utils.assertType(start, 'unit', 'start');
      utils.assertType(stop, 'unit', 'stop');
      if (step) {
        utils.assertType(step, 'unit', 'step');
        if (0 == step.val) {
          throw new Error('ArgumentError: "step" argument must not be zero');
        }
      } else {
        step = new nodes.Unit(1);
      }
      var list = new nodes.Expression();
      for (var i = start.val; i <= stop.val; i += step.val) {
        list.push(new nodes.Unit(i, start.type));
      }
      return list;
    };
  });
  require.register('functions/red.js', function(module, exports, require) {
    var nodes = require('../nodes'),
      rgba = require('./rgba');
    module.exports = function red(color, value) {
      color = color.rgba;
      if (value) {
        return rgba(
          value,
          new nodes.Unit(color.g),
          new nodes.Unit(color.b),
          new nodes.Unit(color.a),
        );
      }
      return new nodes.Unit(color.r, '');
    };
  });
  require.register('functions/remove.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function remove(object, key) {
      utils.assertType(object, 'object', 'object');
      utils.assertString(key, 'key');
      delete object.vals[key.string];
      return object;
    };
  });
  require.register('functions/replace.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function replace(pattern, replacement, val) {
      utils.assertString(pattern, 'pattern');
      utils.assertString(replacement, 'replacement');
      utils.assertString(val, 'val');
      pattern = new RegExp(pattern.string, 'g');
      var res = val.string.replace(pattern, replacement.string);
      return val instanceof nodes.Ident
        ? new nodes.Ident(res)
        : new nodes.String(res);
    };
  });
  require.register('functions/rgb.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes'),
      rgba = require('./rgba');
    module.exports = function rgb(red, green, blue) {
      switch (arguments.length) {
        case 1:
          utils.assertColor(red);
          var color = red.rgba;
          return new nodes.RGBA(color.r, color.g, color.b, 1);
        default:
          return rgba(red, green, blue, new nodes.Unit(1));
      }
    };
  });
  require.register('functions/rgba.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function rgba(red, green, blue, alpha) {
      switch (arguments.length) {
        case 1:
          utils.assertColor(red);
          return red.rgba;
        case 2:
          utils.assertColor(red);
          var color = red.rgba;
          utils.assertType(green, 'unit', 'alpha');
          alpha = green.clone();
          if ('%' == alpha.type) alpha.val /= 100;
          return new nodes.RGBA(color.r, color.g, color.b, alpha.val);
        default:
          utils.assertType(red, 'unit', 'red');
          utils.assertType(green, 'unit', 'green');
          utils.assertType(blue, 'unit', 'blue');
          utils.assertType(alpha, 'unit', 'alpha');
          var r = '%' == red.type ? Math.round(red.val * 2.55) : red.val,
            g = '%' == green.type ? Math.round(green.val * 2.55) : green.val,
            b = '%' == blue.type ? Math.round(blue.val * 2.55) : blue.val;
          alpha = alpha.clone();
          if (alpha && '%' == alpha.type) alpha.val /= 100;
          return new nodes.RGBA(r, g, b, alpha.val);
      }
    };
  });
  require.register('functions/s.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes'),
      Compiler = require('../visitor/compiler');
    (module.exports = function s(fmt) {
      fmt = utils.unwrap(fmt).nodes[0];
      utils.assertString(fmt);
      var self = this,
        str = fmt.string,
        args = arguments,
        i = 1;
      str = str.replace(/%(s|d)/g, function(_, specifier) {
        var arg = args[i++] || nodes.nil;
        switch (specifier) {
          case 's':
            return new Compiler(arg, self.options).compile();
          case 'd':
            arg = utils.unwrap(arg).first;
            if ('unit' != arg.nodeName) throw new Error('%d requires a unit');
            return arg.val;
        }
      });
      return new nodes.Literal(str);
    }).raw = true;
  });
  require.register('functions/saturation.js', function(
    module,
    exports,
    require,
  ) {
    var nodes = require('../nodes'),
      hsla = require('./hsla'),
      component = require('./component');
    module.exports = function saturation(color, value) {
      if (value) {
        var hslaColor = color.hsla;
        return hsla(
          new nodes.Unit(hslaColor.h),
          value,
          new nodes.Unit(hslaColor.l),
          new nodes.Unit(hslaColor.a),
        );
      }
      return component(color, new nodes.String('saturation'));
    };
  });
  require.register('functions/selector-exists.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils');
    module.exports = function selectorExists(sel) {
      utils.assertString(sel, 'selector');
      if (!this.__selectorsMap__) {
        var Normalizer = require('../visitor/normalizer'),
          visitor = new Normalizer(this.root.clone());
        visitor.visit(visitor.root);
        this.__selectorsMap__ = visitor.map;
      }
      return sel.string in this.__selectorsMap__;
    };
  });
  require.register('functions/selector.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function selector() {
      var stack = this.selectorStack,
        args = [].slice.call(arguments);
      if (1 == args.length) {
        var expr = utils.unwrap(args[0]),
          len = expr.nodes.length;
        if (1 == len) {
          utils.assertString(expr.first, 'selector');
          var SelectorParser = require('../selector-parser'),
            val = expr.first.string,
            parsed = new SelectorParser(val).parse().val;
          if (parsed == val) return val;
          stack.push(parse(val));
        } else if (len > 1) {
          if (expr.isList) {
            pushToStack(expr.nodes, stack);
          } else {
            stack.push(
              parse(
                expr.nodes
                  .map(function(node) {
                    utils.assertString(node, 'selector');
                    return node.string;
                  })
                  .join(' '),
              ),
            );
          }
        }
      } else if (args.length > 1) {
        pushToStack(args, stack);
      }
      return stack.length ? utils.compileSelectors(stack).join(',') : '&';
    }).raw = true;
    function pushToStack(selectors, stack) {
      selectors.forEach(function(sel) {
        sel = sel.first;
        utils.assertString(sel, 'selector');
        stack.push(parse(sel.string));
      });
    }
    function parse(selector) {
      var Parser = new require('../parser'),
        parser = new Parser(selector),
        nodes;
      parser.state.push('selector-parts');
      nodes = parser.selector();
      nodes.forEach(function(node) {
        node.val = node.segments
          .map(function(seg) {
            return seg.toString();
          })
          .join('');
      });
      return nodes;
    }
  });
  require.register('functions/selectors.js', function(
    module,
    exports,
    require,
  ) {
    var nodes = require('../nodes'),
      Parser = require('../selector-parser');
    module.exports = function selectors() {
      var stack = this.selectorStack,
        expr = new nodes.Expression(true);
      if (stack.length) {
        for (var i = 0; i < stack.length; i++) {
          var group = stack[i],
            nested;
          if (group.length > 1) {
            expr.push(
              new nodes.String(
                group
                  .map(function(selector) {
                    nested = new Parser(selector.val).parse().nested;
                    return (nested && i ? '& ' : '') + selector.val;
                  })
                  .join(','),
              ),
            );
          } else {
            var selector = group[0].val;
            nested = new Parser(selector).parse().nested;
            expr.push(new nodes.String((nested && i ? '& ' : '') + selector));
          }
        }
      } else {
        expr.push(new nodes.String('&'));
      }
      return expr;
    };
  });
  require.register('functions/shift.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function(expr) {
      expr = utils.unwrap(expr);
      return expr.nodes.shift();
    }).raw = true;
  });
  require.register('functions/split.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function split(delim, val) {
      utils.assertString(delim, 'delimiter');
      utils.assertString(val, 'val');
      var splitted = val.string.split(delim.string);
      var expr = new nodes.Expression();
      var ItemNode = val instanceof nodes.Ident ? nodes.Ident : nodes.String;
      for (var i = 0, len = splitted.length; i < len; ++i) {
        expr.nodes.push(new ItemNode(splitted[i]));
      }
      return expr;
    };
  });
  require.register('functions/slice.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    (module.exports = function slice(val, start, end) {
      start = start && start.nodes[0].val;
      end = end && end.nodes[0].val;
      val = utils.unwrap(val).nodes;
      if (val.length > 1) {
        return utils.coerce(val.slice(start, end), true);
      }
      var result = val[0].string.slice(start, end);
      return val[0] instanceof nodes.Ident
        ? new nodes.Ident(result)
        : new nodes.String(result);
    }).raw = true;
  });
  require.register('functions/substr.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function substr(val, start, length) {
      utils.assertString(val, 'val');
      utils.assertType(start, 'unit', 'start');
      length = length && length.val;
      var res = val.string.substr(start.val, length);
      return val instanceof nodes.Ident
        ? new nodes.Ident(res)
        : new nodes.String(res);
    };
  });
  require.register('functions/tan.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function tan(angle) {
      utils.assertType(angle, 'unit', 'angle');
      var radians = angle.val;
      if (angle.type === 'deg') {
        radians *= Math.PI / 180;
      }
      var m = Math.pow(10, 9);
      var sin = Math.round(Math.sin(radians) * m) / m,
        cos = Math.round(Math.cos(radians) * m) / m,
        tan = Math.round(m * sin / cos) / m;
      return new nodes.Unit(tan, '');
    };
  });
  require.register('functions/trace.js', function(module, exports, require) {
    var nodes = require('../nodes');
    module.exports = function trace() {
      console.log(this.stack);
      return nodes.nil;
    };
  });
  require.register('functions/transparentify.js', function(
    module,
    exports,
    require,
  ) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function transparentify(top, bottom, alpha) {
      utils.assertColor(top);
      top = top.rgba;
      bottom = bottom || new nodes.RGBA(255, 255, 255, 1);
      if (!alpha && bottom && !bottom.rgba) {
        alpha = bottom;
        bottom = new nodes.RGBA(255, 255, 255, 1);
      }
      utils.assertColor(bottom);
      bottom = bottom.rgba;
      var bestAlpha = ['r', 'g', 'b']
        .map(function(channel) {
          return (
            (top[channel] - bottom[channel]) /
            ((0 < top[channel] - bottom[channel] ? 255 : 0) - bottom[channel])
          );
        })
        .sort(function(a, b) {
          return a < b;
        })[0];
      if (alpha) {
        utils.assertType(alpha, 'unit', 'alpha');
        if ('%' == alpha.type) {
          bestAlpha = alpha.val / 100;
        } else if (!alpha.type) {
          bestAlpha = alpha = alpha.val;
        }
      }
      bestAlpha = Math.max(Math.min(bestAlpha, 1), 0);
      function processChannel(channel) {
        if (0 == bestAlpha) {
          return bottom[channel];
        } else {
          return bottom[channel] + (top[channel] - bottom[channel]) / bestAlpha;
        }
      }
      return new nodes.RGBA(
        processChannel('r'),
        processChannel('g'),
        processChannel('b'),
        Math.round(bestAlpha * 100) / 100,
      );
    };
  });
  require.register('functions/type.js', function(module, exports, require) {
    var utils = require('../utils');
    module.exports = function type(node) {
      utils.assertPresent(node, 'expression');
      return node.nodeName;
    };
  });
  require.register('functions/unit.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function unit(unit, type) {
      utils.assertType(unit, 'unit', 'unit');
      if (type) {
        utils.assertString(type, 'type');
        return new nodes.Unit(unit.val, type.string);
      } else {
        return unit.type || '';
      }
    };
  });
  require.register('functions/unquote.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function unquote(string) {
      utils.assertString(string, 'string');
      return new nodes.Literal(string.string);
    };
  });
  require.register('functions/unshift.js', function(module, exports, require) {
    var utils = require('../utils');
    (module.exports = function(expr) {
      expr = utils.unwrap(expr);
      for (var i = 1, len = arguments.length; i < len; ++i) {
        expr.nodes.unshift(utils.unwrap(arguments[i]));
      }
      return expr.nodes.length;
    }).raw = true;
  });
  require.register('functions/warn.js', function(module, exports, require) {
    var utils = require('../utils'),
      nodes = require('../nodes');
    module.exports = function warn(msg) {
      utils.assertType(msg, 'string', 'msg');
      console.warn('Warning: %s', msg.val);
      return nodes.nil;
    };
  });
  require.register('lexer.js', function(module, exports, require) {
    var Token = require('./token'),
      nodes = require('./nodes'),
      errors = require('./errors');
    exports = module.exports = Lexer;
    var alias = {
      and: '&&',
      or: '||',
      is: '==',
      isnt: '!=',
      'is not': '!=',
      ':=': '?=',
    };
    function Lexer(str, options) {
      options = options || {};
      this.stash = [];
      this.indentStack = [];
      this.indentRe = null;
      this.lineno = 1;
      this.column = 1;
      function comment(str, val, offset, s) {
        var inComment =
            s.lastIndexOf('/*', offset) > s.lastIndexOf('*/', offset),
          commentIdx = s.lastIndexOf('//', offset),
          i = s.lastIndexOf('\n', offset),
          double = 0,
          single = 0;
        if (~commentIdx && commentIdx > i) {
          while (i != offset) {
            if ("'" == s[i]) single ? single-- : single++;
            if ('"' == s[i]) double ? double-- : double++;
            if ('/' == s[i] && '/' == s[i + 1]) {
              inComment = !single && !double;
              break;
            }
            ++i;
          }
        }
        return inComment ? str : val + '\r';
      }
      if ('\ufeff' == str.charAt(0)) str = str.slice(1);
      this.str = str
        .replace(/\s+$/, '\n')
        .replace(/\r\n?/g, '\n')
        .replace(/\\ *\n/g, '\r')
        .replace(
          /([,(:](?!\/\/[^ ])) *(?:\/\/[^\n]*|\/\*.*?\*\/)?\n\s*/g,
          comment,
        )
        .replace(/\s*\n[ \t]*([,)])/g, comment);
    }
    Lexer.prototype = {
      inspect: function() {
        var tok,
          tmp = this.str,
          buf = [];
        while ('eos' != (tok = this.next()).type) {
          buf.push(tok.inspect());
        }
        this.str = tmp;
        return buf.concat(tok.inspect()).join('\n');
      },
      lookahead: function(n) {
        var fetch = n - this.stash.length;
        while (fetch-- > 0) this.stash.push(this.advance());
        return this.stash[--n];
      },
      skip: function(len) {
        var chunk = len[0];
        len = chunk ? chunk.length : len;
        this.str = this.str.substr(len);
        if (chunk) {
          this.move(chunk);
        } else {
          this.column += len;
        }
      },
      move: function(str) {
        var lines = str.match(/\n/g),
          idx = str.lastIndexOf('\n');
        if (lines) this.lineno += lines.length;
        this.column = ~idx ? str.length - idx : this.column + str.length;
      },
      next: function() {
        var tok = this.stashed() || this.advance();
        this.prev = tok;
        return tok;
      },
      isPartOfSelector: function() {
        var tok = this.stash[this.stash.length - 1] || this.prev;
        switch (tok && tok.type) {
          case 'color':
            return 2 == tok.val.raw.length;
          case '.':
          case '[':
            return true;
        }
        return false;
      },
      advance: function() {
        var column = this.column,
          line = this.lineno,
          tok =
            this.eos() ||
            this.nil() ||
            this.sep() ||
            this.keyword() ||
            this.urlchars() ||
            this.comment() ||
            this.newline() ||
            this.escaped() ||
            this.important() ||
            this.literal() ||
            this.fun() ||
            this.anonFunc() ||
            this.atrule() ||
            this.brace() ||
            this.paren() ||
            this.color() ||
            this.string() ||
            this.unit() ||
            this.namedop() ||
            this.boolean() ||
            this.unicode() ||
            this.ident() ||
            this.op() ||
            this.eol() ||
            this.space() ||
            this.selector();
        tok.lineno = line;
        tok.column = column;
        return tok;
      },
      peek: function() {
        return this.lookahead(1);
      },
      stashed: function() {
        return this.stash.shift();
      },
      eos: function() {
        if (this.str.length) return;
        if (this.indentStack.length) {
          this.indentStack.shift();
          return new Token('outdent');
        } else {
          return new Token('eos');
        }
      },
      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 = /^;[ \t]*/.exec(this.str))) {
          this.skip(captures);
          return new Token(';');
        }
      },
      eol: function() {
        if ('\r' == this.str[0]) {
          ++this.lineno;
          this.skip(1);
          return this.advance();
        }
      },
      space: function() {
        var captures;
        if ((captures = /^([ \t]+)/.exec(this.str))) {
          this.skip(captures);
          return new Token('space');
        }
      },
      escaped: function() {
        var captures;
        if ((captures = /^\\(.)[ \t]*/.exec(this.str))) {
          var c = captures[1];
          this.skip(captures);
          return new Token('ident', new nodes.Literal(c));
        }
      },
      literal: function() {
        var captures;
        if ((captures = /^@css[ \t]*\{/.exec(this.str))) {
          this.skip(captures);
          var c,
            braces = 1,
            css = '',
            node;
          while ((c = this.str[0])) {
            this.str = this.str.substr(1);
            switch (c) {
              case '{':
                ++braces;
                break;
              case '}':
                --braces;
                break;
              case '\n':
              case '\r':
                ++this.lineno;
                break;
            }
            css += c;
            if (!braces) break;
          }
          css = css.replace(/\s*}$/, '');
          node = new nodes.Literal(css);
          node.css = true;
          return new Token('literal', node);
        }
      },
      important: function() {
        var captures;
        if ((captures = /^!important[ \t]*/.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 = /^([()])([ \t]*)/.exec(this.str))) {
          var paren = captures[1];
          this.skip(captures);
          if (')' == paren) this.isURL = false;
          var tok = new Token(paren, paren);
          tok.space = captures[2];
          return tok;
        }
      },
      nil: function() {
        var captures, tok;
        if ((captures = /^(null)\b[ \t]*/.exec(this.str))) {
          this.skip(captures);
          if (this.isPartOfSelector()) {
            tok = new Token('ident', new nodes.Ident(captures[0]));
          } else {
            tok = new Token('null', nodes.nil);
          }
          return tok;
        }
      },
      keyword: function() {
        var captures, tok;
        if (
          (captures = /^(return|if|else|unless|for|in)\b[ \t]*/.exec(this.str))
        ) {
          var keyword = captures[1];
          this.skip(captures);
          if (this.isPartOfSelector()) {
            tok = new Token('ident', new nodes.Ident(captures[0]));
          } else {
            tok = new Token(keyword, keyword);
          }
          return tok;
        }
      },
      namedop: function() {
        var captures, tok;
        if (
          (captures = /^(not|and|or|is a|is defined|isnt|is not|is)(?!-)\b([ \t]*)/.exec(
            this.str,
          ))
        ) {
          var op = captures[1];
          this.skip(captures);
          if (this.isPartOfSelector()) {
            tok = new Token('ident', new nodes.Ident(captures[0]));
          } else {
            op = alias[op] || op;
            tok = new Token(op, op);
          }
          tok.space = captures[2];
          return tok;
        }
      },
      op: function() {
        var captures;
        if (
          (captures = /^([.]{1,3}|&&|\|\||[!<>=?:]=|\*\*|[-+*\/%]=?|[,=?:!~<>&\[\]])([ \t]*)/.exec(
            this.str,
          ))
        ) {
          var op = captures[1];
          this.skip(captures);
          op = alias[op] || op;
          var tok = new Token(op, op);
          tok.space = captures[2];
          this.isURL = false;
          return tok;
        }
      },
      anonFunc: function() {
        var tok;
        if ('@' == this.str[0] && '(' == this.str[1]) {
          this.skip(2);
          tok = new Token('function', new nodes.Ident('anonymous'));
          tok.anonymous = true;
          return tok;
        }
      },
      atrule: function() {
        var captures;
        if (
          (captures = /^@(?:-(\w+)-)?([a-zA-Z0-9-_]+)[ \t]*/.exec(this.str))
        ) {
          this.skip(captures);
          var vendor = captures[1],
            type = captures[2],
            tok;
          switch (type) {
            case 'require':
            case 'import':
            case 'charset':
            case 'namespace':
            case 'media':
            case 'scope':
            case 'supports':
              return new Token(type);
            case 'document':
              return new Token('-moz-document');
            case 'block':
              return new Token('atblock');
            case 'extend':
            case 'extends':
              return new Token('extend');
            case 'keyframes':
              return new Token(type, vendor);
            default:
              return new Token(
                'atrule',
                vendor ? '-' + vendor + '-' + type : type,
              );
          }
        }
      },
      comment: function() {
        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();
        }
        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|\r/).length - 1,
            suppress = true,
            inline = false;
          this.lineno += lines;
          this.skip(end + 2);
          if ('!' == str[2]) {
            str = str.replace('*!', '*');
            suppress = false;
          }
          if (this.prev && ';' == this.prev.type) inline = true;
          return new Token('comment', new nodes.Comment(str, suppress, inline));
        }
      },
      boolean: function() {
        var captures;
        if ((captures = /^(true|false)\b([ \t]*)/.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;
        }
      },
      unicode: function() {
        var captures;
        if (
          (captures = /^u\+[0-9a-f?]{1,6}(?:-[0-9a-f]{1,6})?/i.exec(this.str))
        ) {
          this.skip(captures);
          return new Token('literal', new nodes.Literal(captures[0]));
        }
      },
      fun: function() {
        var captures;
        if ((captures = /^(-*[_a-zA-Z$][-\w\d$]*)\(([ \t]*)/.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;
        }
      },
      ident: function() {
        var captures;
        if ((captures = /^-*[_a-zA-Z$][-\w\d$]*/.exec(this.str))) {
          this.skip(captures);
          return new Token('ident', new nodes.Ident(captures[0]));
        }
      },
      newline: function() {
        var captures, re;
        if (this.indentRe) {
          captures = this.indentRe.exec(this.str);
        } else {
          re = /^\n([\t]*)[ \t]*/;
          captures = re.exec(this.str);
          if (captures && !captures[1].length) {
            re = /^\n([ \t]*)/;
            captures = re.exec(this.str);
          }
          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] === '	') {
            throw new errors.SyntaxError(
              'Invalid indentation. You can use tabs or spaces to indent, but not both.',
            );
          }
          if ('\n' == this.str[0]) return this.advance();
          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();
          } else if (indents && indents != this.indentStack[0]) {
            this.indentStack.unshift(indents);
            tok = new Token('indent');
          } else {
            tok = new Token('newline');
          }
          return tok;
        }
      },
      unit: function() {
        var captures;
        if (
          (captures = /^(-)?(\d+\.\d+|\d+|\.\d+)(%|[a-zA-Z]+)?[ \t]*/.exec(
            this.str,
          ))
        ) {
          this.skip(captures);
          var n = parseFloat(captures[2]);
          if ('-' == captures[1]) n = -n;
          var node = new nodes.Unit(n, captures[3]);
          node.raw = captures[0];
          return new Token('unit', node);
        }
      },
      string: function() {
        var captures;
        if ((captures = /^("[^"]*"|'[^']*')[ \t]*/.exec(this.str))) {
          var str = captures[1],
            quote = captures[0][0];
          this.skip(captures);
          str = str.slice(1, -1).replace(/\\n/g, '\n');
          return new Token('string', new nodes.String(str, quote));
        }
      },
      color: function() {
        return (
          this.rrggbbaa() ||
          this.rrggbb() ||
          this.rgba() ||
          this.rgb() ||
          this.nn() ||
          this.n()
        );
      },
      n: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{1})[ \t]*/.exec(this.str))) {
          this.skip(captures);
          var n = parseInt(captures[1] + captures[1], 16),
            color = new nodes.RGBA(n, n, n, 1);
          color.raw = captures[0];
          return new Token('color', color);
        }
      },
      nn: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{2})[ \t]*/.exec(this.str))) {
          this.skip(captures);
          var n = parseInt(captures[1], 16),
            color = new nodes.RGBA(n, n, n, 1);
          color.raw = captures[0];
          return new Token('color', color);
        }
      },
      rgb: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{3})[ \t]*/.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: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{4})[ \t]*/.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: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{6})[ \t]*/.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: function() {
        var captures;
        if ((captures = /^#([a-fA-F0-9]{8})[ \t]*/.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);
        }
      },
      selector: function() {
        var captures;
        if ((captures = /^\^|.*?(?=\/\/(?![^\[]*\])|[,\n{])/.exec(this.str))) {
          var selector = captures[0];
          this.skip(captures);
          return new Token('selector', selector);
        }
      },
    };
  });
  require.register('nodes/arguments.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('../nodes'),
      utils = require('../utils');
    var Arguments = (module.exports = function Arguments() {
      nodes.Expression.call(this);
      this.map = {};
    });
    Arguments.prototype.__proto__ = nodes.Expression.prototype;
    Arguments.fromExpression = function(expr) {
      var args = new Arguments(),
        len = expr.nodes.length;
      args.lineno = expr.lineno;
      args.column = expr.column;
      args.isList = expr.isList;
      for (var i = 0; i < len; ++i) {
        args.push(expr.nodes[i]);
      }
      return args;
    };
    Arguments.prototype.clone = function(parent) {
      var clone = nodes.Expression.prototype.clone.call(this, parent);
      clone.map = {};
      for (var key in this.map) {
        clone.map[key] = this.map[key].clone(parent, clone);
      }
      clone.isList = this.isList;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Arguments.prototype.toJSON = function() {
      return {
        __type: 'Arguments',
        map: this.map,
        isList: this.isList,
        preserve: this.preserve,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
        nodes: this.nodes,
      };
    };
  });
  require.register('nodes/binop.js', function(module, exports, require) {
    var Node = require('./node');
    var BinOp = (module.exports = function BinOp(op, left, right) {
      Node.call(this);
      this.op = op;
      this.left = left;
      this.right = right;
    });
    BinOp.prototype.__proto__ = Node.prototype;
    BinOp.prototype.clone = function(parent) {
      var clone = new BinOp(this.op);
      clone.left = this.left.clone(parent, clone);
      clone.right = this.right && this.right.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      if (this.val) clone.val = this.val.clone(parent, clone);
      return clone;
    };
    BinOp.prototype.toString = function() {
      return this.left.toString() + ' ' + this.op + ' ' + this.right.toString();
    };
    BinOp.prototype.toJSON = function() {
      var json = {
        __type: 'BinOp',
        left: this.left,
        right: this.right,
        op: this.op,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.val) json.val = this.val;
      return json;
    };
  });
  require.register('nodes/block.js', function(module, exports, require) {
    var Node = require('./node');
    var Block = (module.exports = function Block(parent, node) {
      Node.call(this);
      this.nodes = [];
      this.parent = parent;
      this.node = node;
      this.scope = true;
    });
    Block.prototype.__proto__ = Node.prototype;
    Block.prototype.__defineGetter__('hasProperties', function() {
      for (var i = 0, len = this.nodes.length; i < len; ++i) {
        if ('property' == this.nodes[i].nodeName) {
          return true;
        }
      }
    });
    Block.prototype.__defineGetter__('hasMedia', function() {
      for (var i = 0, len = this.nodes.length; i < len; ++i) {
        var nodeName = this.nodes[i].nodeName;
        if ('media' == nodeName) {
          return true;
        }
      }
      return false;
    });
    Block.prototype.__defineGetter__('isEmpty', function() {
      return !this.nodes.length;
    });
    Block.prototype.clone = function(parent, node) {
      parent = parent || this.parent;
      var clone = new Block(parent, node || this.node);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.scope = this.scope;
      this.nodes.forEach(function(node) {
        clone.push(node.clone(clone, clone));
      });
      return clone;
    };
    Block.prototype.push = function(node) {
      this.nodes.push(node);
    };
    Block.prototype.toJSON = function() {
      return {
        __type: 'Block',
        scope: this.scope,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
        nodes: this.nodes,
      };
    };
  });
  require.register('nodes/boolean.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Boolean = (module.exports = function Boolean(val) {
      Node.call(this);
      if (this.nodeName) {
        this.val = !!val;
      } else {
        return new Boolean(val);
      }
    });
    Boolean.prototype.__proto__ = Node.prototype;
    Boolean.prototype.toBoolean = function() {
      return this;
    };
    Boolean.prototype.__defineGetter__('isTrue', function() {
      return this.val;
    });
    Boolean.prototype.__defineGetter__('isFalse', function() {
      return !this.val;
    });
    Boolean.prototype.negate = function() {
      return new Boolean(!this.val);
    };
    Boolean.prototype.inspect = function() {
      return '[Boolean ' + this.val + ']';
    };
    Boolean.prototype.toString = function() {
      return this.val ? 'true' : 'false';
    };
    Boolean.prototype.toJSON = function() {
      return { __type: 'Boolean', val: this.val };
    };
  });
  require.register('nodes/call.js', function(module, exports, require) {
    var Node = require('./node');
    var Call = (module.exports = function Call(name, args) {
      Node.call(this);
      this.name = name;
      this.args = args;
    });
    Call.prototype.__proto__ = Node.prototype;
    Call.prototype.clone = function(parent) {
      var clone = new Call(this.name);
      clone.args = this.args.clone(parent, clone);
      if (this.block) clone.block = this.block.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Call.prototype.toString = function() {
      var args = this.args.nodes
        .map(function(node) {
          var str = node.toString();
          return str.slice(1, str.length - 1);
        })
        .join(', ');
      return this.name + '(' + args + ')';
    };
    Call.prototype.toJSON = function() {
      var json = {
        __type: 'Call',
        name: this.name,
        args: this.args,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.block) json.block = this.block;
      return json;
    };
  });
  require.register('nodes/charset.js', function(module, exports, require) {
    var Node = require('./node');
    var Charset = (module.exports = function Charset(val) {
      Node.call(this);
      this.val = val;
    });
    Charset.prototype.__proto__ = Node.prototype;
    Charset.prototype.toString = function() {
      return '@charset ' + this.val;
    };
    Charset.prototype.toJSON = function() {
      return {
        __type: 'Charset',
        val: this.val,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/namespace.js', function(module, exports, require) {
    var Node = require('./node');
    var Namespace = (module.exports = function Namespace(val, prefix) {
      Node.call(this);
      this.val = val;
      this.prefix = prefix;
    });
    Namespace.prototype.__proto__ = Node.prototype;
    Namespace.prototype.toString = function() {
      return '@namespace ' + (this.prefix ? this.prefix + ' ' : '') + this.val;
    };
    Namespace.prototype.toJSON = function() {
      return {
        __type: 'Namespace',
        val: this.val,
        prefix: this.prefix,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/comment.js', function(module, exports, require) {
    var Node = require('./node');
    var Comment = (module.exports = function Comment(str, suppress, inline) {
      Node.call(this);
      this.str = str;
      this.suppress = suppress;
      this.inline = inline;
    });
    Comment.prototype.__proto__ = Node.prototype;
    Comment.prototype.toJSON = function() {
      return {
        __type: 'Comment',
        str: this.str,
        suppress: this.suppress,
        inline: this.inline,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Comment.prototype.toString = function() {
      return this.str;
    };
  });
  require.register('nodes/each.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Each = (module.exports = function Each(val, key, expr, block) {
      Node.call(this);
      this.val = val;
      this.key = key;
      this.expr = expr;
      this.block = block;
    });
    Each.prototype.__proto__ = Node.prototype;
    Each.prototype.clone = function(parent) {
      var clone = new Each(this.val, this.key);
      clone.expr = this.expr.clone(parent, clone);
      clone.block = this.block.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Each.prototype.toJSON = function() {
      return {
        __type: 'Each',
        val: this.val,
        key: this.key,
        expr: this.expr,
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/expression.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('../nodes'),
      utils = require('../utils');
    var Expression = (module.exports = function Expression(isList) {
      Node.call(this);
      this.nodes = [];
      this.isList = isList;
    });
    Expression.prototype.__defineGetter__('isEmpty', function() {
      return !this.nodes.length;
    });
    Expression.prototype.__defineGetter__('first', function() {
      return this.nodes[0] ? this.nodes[0].first : nodes.nil;
    });
    Expression.prototype.__defineGetter__('hash', function() {
      return this.nodes
        .map(function(node) {
          return node.hash;
        })
        .join('::');
    });
    Expression.prototype.__proto__ = Node.prototype;
    Expression.prototype.clone = function(parent) {
      var clone = new this.constructor(this.isList);
      clone.preserve = this.preserve;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.nodes = this.nodes.map(function(node) {
        return node.clone(parent, clone);
      });
      return clone;
    };
    Expression.prototype.push = function(node) {
      this.nodes.push(node);
    };
    Expression.prototype.operate = function(op, right, val) {
      switch (op) {
        case '[]=':
          var self = this,
            range = utils.unwrap(right).nodes,
            val = utils.unwrap(val),
            len,
            node;
          range.forEach(function(unit) {
            len = self.nodes.length;
            if ('unit' == unit.nodeName) {
              var i = unit.val < 0 ? len + unit.val : unit.val,
                n = i;
              while (i-- > len) self.nodes[i] = nodes.nil;
              self.nodes[n] = val;
            } else if (unit.string) {
              node = self.nodes[0];
              if (node && 'object' == node.nodeName)
                node.set(unit.string, val.clone());
            }
          });
          return val;
        case '[]':
          var expr = new nodes.Expression(),
            vals = utils.unwrap(this).nodes,
            range = utils.unwrap(right).nodes,
            node;
          range.forEach(function(unit) {
            if ('unit' == unit.nodeName) {
              node = vals[unit.val < 0 ? vals.length + unit.val : unit.val];
            } else if ('object' == vals[0].nodeName) {
              node = vals[0].get(unit.string);
            }
            if (node) expr.push(node);
          });
          return expr.isEmpty ? nodes.nil : utils.unwrap(expr);
        case '||':
          return this.toBoolean().isTrue ? this : right;
        case 'in':
          return Node.prototype.operate.call(this, op, right);
        case '!=':
          return this.operate('==', right, val).negate();
        case '==':
          var len = this.nodes.length,
            right = right.toExpression(),
            a,
            b;
          if (len != right.nodes.length) return nodes.no;
          for (var i = 0; i < len; ++i) {
            a = this.nodes[i];
            b = right.nodes[i];
            if (a.operate(op, b).isTrue) continue;
            return nodes.no;
          }
          return nodes.yes;
          break;
        default:
          return this.first.operate(op, right, val);
      }
    };
    Expression.prototype.toBoolean = function() {
      if (this.nodes.length > 1) return nodes.yes;
      return this.first.toBoolean();
    };
    Expression.prototype.toString = function() {
      return (
        '(' +
        this.nodes
          .map(function(node) {
            return node.toString();
          })
          .join(this.isList ? ', ' : ' ') +
        ')'
      );
    };
    Expression.prototype.toJSON = function() {
      return {
        __type: 'Expression',
        isList: this.isList,
        preserve: this.preserve,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
        nodes: this.nodes,
      };
    };
  });
  require.register('nodes/function.js', function(module, exports, require) {
    var Node = require('./node');
    var Function = (module.exports = function Function(name, params, body) {
      Node.call(this);
      this.name = name;
      this.params = params;
      this.block = body;
      if ('function' == typeof params) this.fn = params;
    });
    Function.prototype.__defineGetter__('arity', function() {
      return this.params.length;
    });
    Function.prototype.__proto__ = Node.prototype;
    Function.prototype.__defineGetter__('hash', function() {
      return 'function ' + this.name;
    });
    Function.prototype.clone = function(parent) {
      if (this.fn) {
        var clone = new Function(this.name, this.fn);
      } else {
        var clone = new Function(this.name);
        clone.params = this.params.clone(parent, clone);
        clone.block = this.block.clone(parent, clone);
      }
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Function.prototype.toString = function() {
      if (this.fn) {
        return (
          this.name +
          '(' +
          this.fn
            .toString()
            .match(/^function *\w*\((.*?)\)/)
            .slice(1)
            .join(', ') +
          ')'
        );
      } else {
        return this.name + '(' + this.params.nodes.join(', ') + ')';
      }
    };
    Function.prototype.toJSON = function() {
      var json = {
        __type: 'Function',
        name: this.name,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.fn) {
        json.fn = this.fn;
      } else {
        json.params = this.params;
        json.block = this.block;
      }
      return json;
    };
  });
  require.register('nodes/group.js', function(module, exports, require) {
    var Node = require('./node');
    var Group = (module.exports = function Group() {
      Node.call(this);
      this.nodes = [];
      this.extends = [];
    });
    Group.prototype.__proto__ = Node.prototype;
    Group.prototype.push = function(selector) {
      this.nodes.push(selector);
    };
    Group.prototype.__defineGetter__('block', function() {
      return this.nodes[0].block;
    });
    Group.prototype.__defineSetter__('block', function(block) {
      for (var i = 0, len = this.nodes.length; i < len; ++i) {
        this.nodes[i].block = block;
      }
    });
    Group.prototype.__defineGetter__('hasOnlyPlaceholders', function() {
      return this.nodes.every(function(selector) {
        return selector.isPlaceholder;
      });
    });
    Group.prototype.clone = function(parent) {
      var clone = new Group();
      clone.lineno = this.lineno;
      clone.column = this.column;
      this.nodes.forEach(function(node) {
        clone.push(node.clone(parent, clone));
      });
      clone.filename = this.filename;
      clone.block = this.block.clone(parent, clone);
      return clone;
    };
    Group.prototype.toJSON = function() {
      return {
        __type: 'Group',
        nodes: this.nodes,
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/hsla.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var HSLA = (exports = module.exports = function HSLA(h, s, l, a) {
      Node.call(this);
      this.h = clampDegrees(h);
      this.s = clampPercentage(s);
      this.l = clampPercentage(l);
      this.a = clampAlpha(a);
      this.hsla = this;
    });
    HSLA.prototype.__proto__ = Node.prototype;
    HSLA.prototype.toString = function() {
      return (
        'hsla(' +
        this.h +
        ',' +
        this.s.toFixed(0) +
        '%,' +
        this.l.toFixed(0) +
        '%,' +
        this.a +
        ')'
      );
    };
    HSLA.prototype.clone = function(parent) {
      var clone = new HSLA(this.h, this.s, this.l, this.a);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    HSLA.prototype.toJSON = function() {
      return {
        __type: 'HSLA',
        h: this.h,
        s: this.s,
        l: this.l,
        a: this.a,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    HSLA.prototype.__defineGetter__('rgba', function() {
      return nodes.RGBA.fromHSLA(this);
    });
    HSLA.prototype.__defineGetter__('hash', function() {
      return this.rgba.toString();
    });
    HSLA.prototype.add = function(h, s, l) {
      return new HSLA(this.h + h, this.s + s, this.l + l, this.a);
    };
    HSLA.prototype.sub = function(h, s, l) {
      return this.add(-h, -s, -l);
    };
    HSLA.prototype.operate = function(op, right) {
      switch (op) {
        case '==':
        case '!=':
        case '<=':
        case '>=':
        case '<':
        case '>':
        case 'is a':
        case '||':
        case '&&':
          return this.rgba.operate(op, right);
        default:
          return this.rgba.operate(op, right).hsla;
      }
    };
    exports.fromRGBA = function(rgba) {
      var r = rgba.r / 255,
        g = rgba.g / 255,
        b = rgba.b / 255,
        a = rgba.a;
      var min = Math.min(r, g, b),
        max = Math.max(r, g, b),
        l = (max + min) / 2,
        d = max - min,
        h,
        s;
      switch (max) {
        case min:
          h = 0;
          break;
        case r:
          h = 60 * (g - b) / d;
          break;
        case g:
          h = 60 * (b - r) / d + 120;
          break;
        case b:
          h = 60 * (r - g) / d + 240;
          break;
      }
      if (max == min) {
        s = 0;
      } else if (l < 0.5) {
        s = d / (2 * l);
      } else {
        s = d / (2 - 2 * l);
      }
      h %= 360;
      s *= 100;
      l *= 100;
      return new HSLA(h, s, l, a);
    };
    HSLA.prototype.adjustLightness = function(percent) {
      this.l = clampPercentage(this.l + this.l * (percent / 100));
      return this;
    };
    HSLA.prototype.adjustHue = function(deg) {
      this.h = clampDegrees(this.h + deg);
      return this;
    };
    function clampDegrees(n) {
      n = n % 360;
      return n >= 0 ? n : 360 + n;
    }
    function clampPercentage(n) {
      return Math.max(0, Math.min(n, 100));
    }
    function clampAlpha(n) {
      return Math.max(0, Math.min(n, 1));
    }
  });
  require.register('nodes/ident.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Ident = (module.exports = function Ident(name, val, mixin) {
      Node.call(this);
      this.name = name;
      this.string = name;
      this.val = val || nodes.nil;
      this.mixin = !!mixin;
    });
    Ident.prototype.__defineGetter__('isEmpty', function() {
      return undefined == this.val;
    });
    Ident.prototype.__defineGetter__('hash', function() {
      return this.name;
    });
    Ident.prototype.__proto__ = Node.prototype;
    Ident.prototype.clone = function(parent) {
      var clone = new Ident(this.name);
      clone.val = this.val.clone(parent, clone);
      clone.mixin = this.mixin;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.property = this.property;
      clone.rest = this.rest;
      return clone;
    };
    Ident.prototype.toJSON = function() {
      return {
        __type: 'Ident',
        name: this.name,
        val: this.val,
        mixin: this.mixin,
        property: this.property,
        rest: this.rest,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Ident.prototype.toString = function() {
      return this.name;
    };
    Ident.prototype.coerce = function(other) {
      switch (other.nodeName) {
        case 'ident':
        case 'string':
        case 'literal':
          return new Ident(other.string);
        case 'unit':
          return new Ident(other.toString());
        default:
          return Node.prototype.coerce.call(this, other);
      }
    };
    Ident.prototype.operate = function(op, right) {
      var val = right.first;
      switch (op) {
        case '-':
          if ('unit' == val.nodeName) {
            var expr = new nodes.Expression();
            val = val.clone();
            val.val = -val.val;
            expr.push(this);
            expr.push(val);
            return expr;
          }
        case '+':
          return new nodes.Ident(this.string + this.coerce(val).string);
      }
      return Node.prototype.operate.call(this, op, right);
    };
  });
  require.register('nodes/if.js', function(module, exports, require) {
    var Node = require('./node');
    var If = (module.exports = function If(cond, negate) {
      Node.call(this);
      this.cond = cond;
      this.elses = [];
      if (negate && negate.nodeName) {
        this.block = negate;
      } else {
        this.negate = negate;
      }
    });
    If.prototype.__proto__ = Node.prototype;
    If.prototype.clone = function(parent) {
      var clone = new If();
      clone.cond = this.cond.clone(parent, clone);
      clone.block = this.block.clone(parent, clone);
      clone.elses = this.elses.map(function(node) {
        return node.clone(parent, clone);
      });
      clone.negate = this.negate;
      clone.postfix = this.postfix;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    If.prototype.toJSON = function() {
      return {
        __type: 'If',
        cond: this.cond,
        block: this.block,
        elses: this.elses,
        negate: this.negate,
        postfix: this.postfix,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/import.js', function(module, exports, require) {
    var Node = require('./node');
    var Import = (module.exports = function Import(expr, once) {
      Node.call(this);
      this.path = expr;
      this.once = once || false;
    });
    Import.prototype.__proto__ = Node.prototype;
    Import.prototype.clone = function(parent) {
      var clone = new Import();
      clone.path = this.path.nodeName
        ? this.path.clone(parent, clone)
        : this.path;
      clone.once = this.once;
      clone.mtime = this.mtime;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Import.prototype.toJSON = function() {
      return {
        __type: 'Import',
        path: this.path,
        once: this.once,
        mtime: this.mtime,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/extend.js', function(module, exports, require) {
    var Node = require('./node');
    var Extend = (module.exports = function Extend(selectors) {
      Node.call(this);
      this.selectors = selectors;
    });
    Extend.prototype.__proto__ = Node.prototype;
    Extend.prototype.clone = function() {
      return new Extend(this.selectors);
    };
    Extend.prototype.toString = function() {
      return '@extend ' + this.selectors.join(', ');
    };
    Extend.prototype.toJSON = function() {
      return {
        __type: 'Extend',
        selectors: this.selectors,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/index.js', function(module, exports, require) {
    exports.Node = require('./node');
    exports.Root = require('./root');
    exports.Null = require('./null');
    exports.Each = require('./each');
    exports.If = require('./if');
    exports.Call = require('./call');
    exports.UnaryOp = require('./unaryop');
    exports.BinOp = require('./binop');
    exports.Ternary = require('./ternary');
    exports.Block = require('./block');
    exports.Unit = require('./unit');
    exports.String = require('./string');
    exports.HSLA = require('./hsla');
    exports.RGBA = require('./rgba');
    exports.Ident = require('./ident');
    exports.Group = require('./group');
    exports.Literal = require('./literal');
    exports.Boolean = require('./boolean');
    exports.Return = require('./return');
    exports.Media = require('./media');
    exports.QueryList = require('./query-list');
    exports.Query = require('./query');
    exports.Feature = require('./feature');
    exports.Params = require('./params');
    exports.Comment = require('./comment');
    exports.Keyframes = require('./keyframes');
    exports.Member = require('./member');
    exports.Charset = require('./charset');
    exports.Namespace = require('./namespace');
    exports.Import = require('./import');
    exports.Extend = require('./extend');
    exports.Object = require('./object');
    exports.Function = require('./function');
    exports.Property = require('./property');
    exports.Selector = require('./selector');
    exports.Expression = require('./expression');
    exports.Arguments = require('./arguments');
    exports.Atblock = require('./atblock');
    exports.Atrule = require('./atrule');
    exports.Supports = require('./supports');
    exports.yes = new exports.Boolean(true);
    exports.no = new exports.Boolean(false);
    exports.nil = new exports.Null();
  });
  require.register('nodes/keyframes.js', function(module, exports, require) {
    var Atrule = require('./atrule');
    var Keyframes = (module.exports = function Keyframes(segs, prefix) {
      Atrule.call(this, 'keyframes');
      this.segments = segs;
      this.prefix = prefix || 'official';
    });
    Keyframes.prototype.__proto__ = Atrule.prototype;
    Keyframes.prototype.clone = function(parent) {
      var clone = new Keyframes();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.segments = this.segments.map(function(node) {
        return node.clone(parent, clone);
      });
      clone.prefix = this.prefix;
      clone.block = this.block.clone(parent, clone);
      return clone;
    };
    Keyframes.prototype.toJSON = function() {
      return {
        __type: 'Keyframes',
        segments: this.segments,
        prefix: this.prefix,
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Keyframes.prototype.toString = function() {
      return '@keyframes ' + this.segments.join('');
    };
  });
  require.register('nodes/literal.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Literal = (module.exports = function Literal(str) {
      Node.call(this);
      this.val = str;
      this.string = str;
      this.prefixed = false;
    });
    Literal.prototype.__proto__ = Node.prototype;
    Literal.prototype.__defineGetter__('hash', function() {
      return this.val;
    });
    Literal.prototype.toString = function() {
      return this.val;
    };
    Literal.prototype.coerce = function(other) {
      switch (other.nodeName) {
        case 'ident':
        case 'string':
        case 'literal':
          return new Literal(other.string);
        default:
          return Node.prototype.coerce.call(this, other);
      }
    };
    Literal.prototype.operate = function(op, right) {
      var val = right.first;
      switch (op) {
        case '+':
          return new nodes.Literal(this.string + this.coerce(val).string);
        default:
          return Node.prototype.operate.call(this, op, right);
      }
    };
    Literal.prototype.toJSON = function() {
      return {
        __type: 'Literal',
        val: this.val,
        string: this.string,
        prefixed: this.prefixed,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/media.js', function(module, exports, require) {
    var Atrule = require('./atrule');
    var Media = (module.exports = function Media(val) {
      Atrule.call(this, 'media');
      this.val = val;
    });
    Media.prototype.__proto__ = Atrule.prototype;
    Media.prototype.clone = function(parent) {
      var clone = new Media();
      clone.val = this.val.clone(parent, clone);
      clone.block = this.block.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Media.prototype.toJSON = function() {
      return {
        __type: 'Media',
        val: this.val,
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Media.prototype.toString = function() {
      return '@media ' + this.val;
    };
  });
  require.register('nodes/query-list.js', function(module, exports, require) {
    var Node = require('./node');
    var QueryList = (module.exports = function QueryList() {
      Node.call(this);
      this.nodes = [];
    });
    QueryList.prototype.__proto__ = Node.prototype;
    QueryList.prototype.clone = function(parent) {
      var clone = new QueryList();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      for (var i = 0; i < this.nodes.length; ++i) {
        clone.push(this.nodes[i].clone(parent, clone));
      }
      return clone;
    };
    QueryList.prototype.push = function(node) {
      this.nodes.push(node);
    };
    QueryList.prototype.merge = function(other) {
      var list = new QueryList(),
        merged;
      this.nodes.forEach(function(query) {
        for (var i = 0, len = other.nodes.length; i < len; ++i) {
          merged = query.merge(other.nodes[i]);
          if (merged) list.push(merged);
        }
      });
      return list;
    };
    QueryList.prototype.toString = function() {
      return (
        '(' +
        this.nodes
          .map(function(node) {
            return node.toString();
          })
          .join(', ') +
        ')'
      );
    };
    QueryList.prototype.toJSON = function() {
      return {
        __type: 'QueryList',
        nodes: this.nodes,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/query.js', function(module, exports, require) {
    var Node = require('./node');
    var Query = (module.exports = function Query() {
      Node.call(this);
      this.nodes = [];
      this.type = '';
      this.predicate = '';
    });
    Query.prototype.__proto__ = Node.prototype;
    Query.prototype.clone = function(parent) {
      var clone = new Query();
      clone.predicate = this.predicate;
      clone.type = this.type;
      for (var i = 0, len = this.nodes.length; i < len; ++i) {
        clone.push(this.nodes[i].clone(parent, clone));
      }
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Query.prototype.push = function(feature) {
      this.nodes.push(feature);
    };
    Query.prototype.__defineGetter__('resolvedType', function() {
      if (this.type) {
        return this.type.nodeName ? this.type.string : this.type;
      }
    });
    Query.prototype.__defineGetter__('resolvedPredicate', function() {
      if (this.predicate) {
        return this.predicate.nodeName ? this.predicate.string : this.predicate;
      }
    });
    Query.prototype.merge = function(other) {
      var query = new Query(),
        p1 = this.resolvedPredicate,
        p2 = other.resolvedPredicate,
        t1 = this.resolvedType,
        t2 = other.resolvedType,
        type,
        pred;
      t1 = t1 || t2;
      t2 = t2 || t1;
      if (('not' == p1) ^ ('not' == p2)) {
        if (t1 == t2) return;
        type = 'not' == p1 ? t2 : t1;
        pred = 'not' == p1 ? p2 : p1;
      } else if ('not' == p1 && 'not' == p2) {
        if (t1 != t2) return;
        type = t1;
        pred = 'not';
      } else if (t1 != t2) {
        return;
      } else {
        type = t1;
        pred = p1 || p2;
      }
      query.predicate = pred;
      query.type = type;
      query.nodes = this.nodes.concat(other.nodes);
      return query;
    };
    Query.prototype.toString = function() {
      var pred = this.predicate ? this.predicate + ' ' : '',
        type = this.type || '',
        len = this.nodes.length,
        str = pred + type;
      if (len) {
        str +=
          (type && ' and ') +
          this.nodes
            .map(function(expr) {
              return expr.toString();
            })
            .join(' and ');
      }
      return str;
    };
    Query.prototype.toJSON = function() {
      return {
        __type: 'Query',
        predicate: this.predicate,
        type: this.type,
        nodes: this.nodes,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/feature.js', function(module, exports, require) {
    var Node = require('./node');
    var Feature = (module.exports = function Feature(segs) {
      Node.call(this);
      this.segments = segs;
      this.expr = null;
    });
    Feature.prototype.__proto__ = Node.prototype;
    Feature.prototype.clone = function(parent) {
      var clone = new Feature();
      clone.segments = this.segments.map(function(node) {
        return node.clone(parent, clone);
      });
      if (this.expr) clone.expr = this.expr.clone(parent, clone);
      if (this.name) clone.name = this.name;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Feature.prototype.toString = function() {
      if (this.expr) {
        return '(' + this.segments.join('') + ': ' + this.expr.toString() + ')';
      } else {
        return this.segments.join('');
      }
    };
    Feature.prototype.toJSON = function() {
      var json = {
        __type: 'Feature',
        segments: this.segments,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.expr) json.expr = this.expr;
      if (this.name) json.name = this.name;
      return json;
    };
  });
  require.register('nodes/node.js', function(module, exports, require) {
    var Evaluator = require('../visitor/evaluator'),
      utils = require('../utils'),
      nodes = require('./index');
    function CoercionError(msg) {
      this.name = 'CoercionError';
      this.message = msg;
      Error.captureStackTrace(this, CoercionError);
    }
    CoercionError.prototype.__proto__ = Error.prototype;
    var Node = (module.exports = function Node() {
      this.lineno = nodes.lineno || 1;
      this.column = nodes.column || 1;
      this.filename = nodes.filename;
    });
    Node.prototype = {
      constructor: Node,
      get first() {
        return this;
      },
      get hash() {
        return this.val;
      },
      get nodeName() {
        return this.constructor.name.toLowerCase();
      },
      clone: function() {
        return this;
      },
      toJSON: function() {
        return {
          lineno: this.lineno,
          column: this.column,
          filename: this.filename,
        };
      },
      eval: function() {
        return new Evaluator(this).evaluate();
      },
      toBoolean: function() {
        return nodes.yes;
      },
      toExpression: function() {
        if ('expression' == this.nodeName) return this;
        var expr = new nodes.Expression();
        expr.push(this);
        return expr;
      },
      shouldCoerce: function(op) {
        switch (op) {
          case 'is a':
          case 'in':
          case '||':
          case '&&':
            return false;
          default:
            return true;
        }
      },
      operate: function(op, right) {
        switch (op) {
          case 'is a':
            if ('string' == right.first.nodeName) {
              return nodes.Boolean(this.nodeName == right.val);
            } else {
              throw new Error(
                '"is a" expects a string, got ' + right.toString(),
              );
            }
          case '==':
            return nodes.Boolean(this.hash == right.hash);
          case '!=':
            return nodes.Boolean(this.hash != right.hash);
          case '>=':
            return nodes.Boolean(this.hash >= right.hash);
          case '<=':
            return nodes.Boolean(this.hash <= right.hash);
          case '>':
            return nodes.Boolean(this.hash > right.hash);
          case '<':
            return nodes.Boolean(this.hash < right.hash);
          case '||':
            return this.toBoolean().isTrue ? this : right;
          case 'in':
            var vals = utils.unwrap(right).nodes,
              len = vals && vals.length,
              hash = this.hash;
            if (!vals)
              throw new Error(
                '"in" given invalid right-hand operand, expecting an expression',
              );
            if (1 == len && 'object' == vals[0].nodeName) {
              return nodes.Boolean(vals[0].has(this.hash));
            }
            for (var i = 0; i < len; ++i) {
              if (hash == vals[i].hash) {
                return nodes.yes;
              }
            }
            return nodes.no;
          case '&&':
            var a = this.toBoolean(),
              b = right.toBoolean();
            return a.isTrue && b.isTrue ? right : a.isFalse ? this : right;
          default:
            if ('[]' == op) {
              var msg = 'cannot perform ' + this + '[' + right + ']';
            } else {
              var msg = 'cannot perform' + ' ' + this + ' ' + op + ' ' + right;
            }
            throw new Error(msg);
        }
      },
      coerce: function(other) {
        if (other.nodeName == this.nodeName) return other;
        throw new CoercionError(
          'cannot coerce ' + other + ' to ' + this.nodeName,
        );
      },
    };
  });
  require.register('nodes/null.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Null = (module.exports = function Null() {});
    Null.prototype.__proto__ = Node.prototype;
    Null.prototype.inspect = Null.prototype.toString = function() {
      return 'null';
    };
    Null.prototype.toBoolean = function() {
      return nodes.no;
    };
    Null.prototype.__defineGetter__('isNull', function() {
      return true;
    });
    Null.prototype.__defineGetter__('hash', function() {
      return null;
    });
    Null.prototype.toJSON = function() {
      return {
        __type: 'Null',
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/params.js', function(module, exports, require) {
    var Node = require('./node');
    var Params = (module.exports = function Params() {
      Node.call(this);
      this.nodes = [];
    });
    Params.prototype.__defineGetter__('length', function() {
      return this.nodes.length;
    });
    Params.prototype.__proto__ = Node.prototype;
    Params.prototype.push = function(node) {
      this.nodes.push(node);
    };
    Params.prototype.clone = function(parent) {
      var clone = new Params();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      this.nodes.forEach(function(node) {
        clone.push(node.clone(parent, clone));
      });
      return clone;
    };
    Params.prototype.toJSON = function() {
      return {
        __type: 'Params',
        nodes: this.nodes,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/property.js', function(module, exports, require) {
    var Node = require('./node');
    var Property = (module.exports = function Property(segs, expr) {
      Node.call(this);
      this.segments = segs;
      this.expr = expr;
    });
    Property.prototype.__proto__ = Node.prototype;
    Property.prototype.clone = function(parent) {
      var clone = new Property(this.segments);
      clone.name = this.name;
      if (this.literal) clone.literal = this.literal;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.segments = this.segments.map(function(node) {
        return node.clone(parent, clone);
      });
      if (this.expr) clone.expr = this.expr.clone(parent, clone);
      return clone;
    };
    Property.prototype.toJSON = function() {
      var json = {
        __type: 'Property',
        segments: this.segments,
        name: this.name,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.expr) json.expr = this.expr;
      if (this.literal) json.literal = this.literal;
      return json;
    };
    Property.prototype.toString = function() {
      return 'property(' + this.segments.join('') + ', ' + this.expr + ')';
    };
    Property.prototype.operate = function(op, right, val) {
      return this.expr.operate(op, right, val);
    };
  });
  require.register('nodes/return.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var Return = (module.exports = function Return(expr) {
      this.expr = expr || nodes.nil;
    });
    Return.prototype.__proto__ = Node.prototype;
    Return.prototype.clone = function(parent) {
      var clone = new Return();
      clone.expr = this.expr.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Return.prototype.toJSON = function() {
      return {
        __type: 'Return',
        expr: this.expr,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/rgba.js', function(module, exports, require) {
    var Node = require('./node'),
      HSLA = require('./hsla'),
      functions = require('../functions'),
      adjust = functions.adjust,
      nodes = require('./index');
    var RGBA = (exports = module.exports = function RGBA(r, g, b, a) {
      Node.call(this);
      this.r = clamp(r);
      this.g = clamp(g);
      this.b = clamp(b);
      this.a = clampAlpha(a);
      this.name = '';
      this.rgba = this;
    });
    RGBA.prototype.__proto__ = Node.prototype;
    RGBA.withoutClamping = function(r, g, b, a) {
      var rgba = new RGBA(0, 0, 0, 0);
      rgba.r = r;
      rgba.g = g;
      rgba.b = b;
      rgba.a = a;
      return rgba;
    };
    RGBA.prototype.clone = function() {
      var clone = new RGBA(this.r, this.g, this.b, this.a);
      clone.raw = this.raw;
      clone.name = this.name;
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    RGBA.prototype.toJSON = function() {
      return {
        __type: 'RGBA',
        r: this.r,
        g: this.g,
        b: this.b,
        a: this.a,
        raw: this.raw,
        name: this.name,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    RGBA.prototype.toBoolean = function() {
      return nodes.yes;
    };
    RGBA.prototype.__defineGetter__('hsla', function() {
      return HSLA.fromRGBA(this);
    });
    RGBA.prototype.__defineGetter__('hash', function() {
      return this.toString();
    });
    RGBA.prototype.add = function(r, g, b, a) {
      return new RGBA(this.r + r, this.g + g, this.b + b, this.a + a);
    };
    RGBA.prototype.sub = function(r, g, b, a) {
      return new RGBA(
        this.r - r,
        this.g - g,
        this.b - b,
        a == 1 ? this.a : this.a - a,
      );
    };
    RGBA.prototype.multiply = function(n) {
      return new RGBA(this.r * n, this.g * n, this.b * n, this.a);
    };
    RGBA.prototype.divide = function(n) {
      return new RGBA(this.r / n, this.g / n, this.b / n, this.a);
    };
    RGBA.prototype.operate = function(op, right) {
      if ('in' != op) right = right.first;
      switch (op) {
        case 'is a':
          if ('string' == right.nodeName && 'color' == right.string) {
            return nodes.yes;
          }
          break;
        case '+':
          switch (right.nodeName) {
            case 'unit':
              var n = right.val;
              switch (right.type) {
                case '%':
                  return adjust(this, new nodes.String('lightness'), right);
                case 'deg':
                  return this.hsla.adjustHue(n).rgba;
                default:
                  return this.add(n, n, n, 0);
              }
            case 'rgba':
              return this.add(right.r, right.g, right.b, right.a);
            case 'hsla':
              return this.hsla.add(right.h, right.s, right.l);
          }
          break;
        case '-':
          switch (right.nodeName) {
            case 'unit':
              var n = right.val;
              switch (right.type) {
                case '%':
                  return adjust(
                    this,
                    new nodes.String('lightness'),
                    new nodes.Unit(-n, '%'),
                  );
                case 'deg':
                  return this.hsla.adjustHue(-n).rgba;
                default:
                  return this.sub(n, n, n, 0);
              }
            case 'rgba':
              return this.sub(right.r, right.g, right.b, right.a);
            case 'hsla':
              return this.hsla.sub(right.h, right.s, right.l);
          }
          break;
        case '*':
          switch (right.nodeName) {
            case 'unit':
              return this.multiply(right.val);
          }
          break;
        case '/':
          switch (right.nodeName) {
            case 'unit':
              return this.divide(right.val);
          }
          break;
      }
      return Node.prototype.operate.call(this, op, right);
    };
    RGBA.prototype.toString = function() {
      function pad(n) {
        return n < 16 ? '0' + n.toString(16) : n.toString(16);
      }
      if ('transparent' == this.name) return this.name;
      if (1 == this.a) {
        var r = pad(this.r),
          g = pad(this.g),
          b = pad(this.b);
        if (r[0] == r[1] && g[0] == g[1] && b[0] == b[1]) {
          return '#' + r[0] + g[0] + b[0];
        } else {
          return '#' + r + g + b;
        }
      } else {
        return (
          'rgba(' +
          this.r +
          ',' +
          this.g +
          ',' +
          this.b +
          ',' +
          +this.a.toFixed(3) +
          ')'
        );
      }
    };
    exports.fromHSLA = function(hsla) {
      var h = hsla.h / 360,
        s = hsla.s / 100,
        l = hsla.l / 100,
        a = hsla.a;
      var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s,
        m1 = l * 2 - m2;
      var r = hue(h + 1 / 3) * 255,
        g = hue(h) * 255,
        b = hue(h - 1 / 3) * 255;
      function hue(h) {
        if (h < 0) ++h;
        if (h > 1) --h;
        if (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
        if (h * 2 < 1) return m2;
        if (h * 3 < 2) return m1 + (m2 - m1) * (2 / 3 - h) * 6;
        return m1;
      }
      return new RGBA(r, g, b, a);
    };
    function clamp(n) {
      return Math.max(0, Math.min(n.toFixed(0), 255));
    }
    function clampAlpha(n) {
      return Math.max(0, Math.min(n, 1));
    }
  });
  require.register('nodes/root.js', function(module, exports, require) {
    var Node = require('./node');
    var Root = (module.exports = function Root() {
      this.nodes = [];
    });
    Root.prototype.__proto__ = Node.prototype;
    Root.prototype.push = function(node) {
      this.nodes.push(node);
    };
    Root.prototype.unshift = function(node) {
      this.nodes.unshift(node);
    };
    Root.prototype.clone = function() {
      var clone = new Root();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      this.nodes.forEach(function(node) {
        clone.push(node.clone(clone, clone));
      });
      return clone;
    };
    Root.prototype.toString = function() {
      return '[Root]';
    };
    Root.prototype.toJSON = function() {
      return {
        __type: 'Root',
        nodes: this.nodes,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/selector.js', function(module, exports, require) {
    var Block = require('./block'),
      Node = require('./node');
    var Selector = (module.exports = function Selector(segs) {
      Node.call(this);
      this.inherits = true;
      this.segments = segs;
      this.optional = false;
    });
    Selector.prototype.__proto__ = Node.prototype;
    Selector.prototype.toString = function() {
      return this.segments.join('') + (this.optional ? ' !optional' : '');
    };
    Selector.prototype.__defineGetter__('isPlaceholder', function() {
      return this.val && ~this.val.substr(0, 2).indexOf('$');
    });
    Selector.prototype.clone = function(parent) {
      var clone = new Selector();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      clone.inherits = this.inherits;
      clone.val = this.val;
      clone.segments = this.segments.map(function(node) {
        return node.clone(parent, clone);
      });
      clone.optional = this.optional;
      return clone;
    };
    Selector.prototype.toJSON = function() {
      return {
        __type: 'Selector',
        inherits: this.inherits,
        segments: this.segments,
        optional: this.optional,
        val: this.val,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/string.js', function(module, exports, require) {
    var Node = require('./node'),
      sprintf = require('../functions').s,
      utils = require('../utils'),
      nodes = require('./index');
    var String = (module.exports = function String(val, quote) {
      Node.call(this);
      this.val = val;
      this.string = val;
      this.prefixed = false;
      if (typeof quote !== 'string') {
        this.quote = "'";
      } else {
        this.quote = quote;
      }
    });
    String.prototype.__proto__ = Node.prototype;
    String.prototype.toString = function() {
      return this.quote + this.val + this.quote;
    };
    String.prototype.clone = function() {
      var clone = new String(this.val, this.quote);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    String.prototype.toJSON = function() {
      return {
        __type: 'String',
        val: this.val,
        quote: this.quote,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    String.prototype.toBoolean = function() {
      return nodes.Boolean(this.val.length);
    };
    String.prototype.coerce = function(other) {
      switch (other.nodeName) {
        case 'string':
          return other;
        case 'expression':
          return new String(
            other.nodes
              .map(function(node) {
                return this.coerce(node).val;
              }, this)
              .join(' '),
          );
        default:
          return new String(other.toString());
      }
    };
    String.prototype.operate = function(op, right) {
      switch (op) {
        case '%':
          var expr = new nodes.Expression();
          expr.push(this);
          var args =
            'expression' == right.nodeName
              ? utils.unwrap(right).nodes
              : [right];
          return sprintf.apply(null, [expr].concat(args));
        case '+':
          var expr = new nodes.Expression();
          expr.push(new String(this.val + this.coerce(right).val));
          return expr;
        default:
          return Node.prototype.operate.call(this, op, right);
      }
    };
  });
  require.register('nodes/ternary.js', function(module, exports, require) {
    var Node = require('./node');
    var Ternary = (module.exports = function Ternary(
      cond,
      trueExpr,
      falseExpr,
    ) {
      Node.call(this);
      this.cond = cond;
      this.trueExpr = trueExpr;
      this.falseExpr = falseExpr;
    });
    Ternary.prototype.__proto__ = Node.prototype;
    Ternary.prototype.clone = function(parent) {
      var clone = new Ternary();
      clone.cond = this.cond.clone(parent, clone);
      clone.trueExpr = this.trueExpr.clone(parent, clone);
      clone.falseExpr = this.falseExpr.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Ternary.prototype.toJSON = function() {
      return {
        __type: 'Ternary',
        cond: this.cond,
        trueExpr: this.trueExpr,
        falseExpr: this.falseExpr,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/unaryop.js', function(module, exports, require) {
    var Node = require('./node');
    var UnaryOp = (module.exports = function UnaryOp(op, expr) {
      Node.call(this);
      this.op = op;
      this.expr = expr;
    });
    UnaryOp.prototype.__proto__ = Node.prototype;
    UnaryOp.prototype.clone = function(parent) {
      var clone = new UnaryOp(this.op);
      clone.expr = this.expr.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    UnaryOp.prototype.toJSON = function() {
      return {
        __type: 'UnaryOp',
        op: this.op,
        expr: this.expr,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
  });
  require.register('nodes/unit.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index');
    var FACTOR_TABLE = {
      mm: { val: 1, label: 'mm' },
      cm: { val: 10, label: 'mm' },
      in: { val: 25.4, label: 'mm' },
      pt: { val: 25.4 / 72, label: 'mm' },
      ms: { val: 1, label: 'ms' },
      s: { val: 1e3, label: 'ms' },
      Hz: { val: 1, label: 'Hz' },
      kHz: { val: 1e3, label: 'Hz' },
    };
    var Unit = (module.exports = function Unit(val, type) {
      Node.call(this);
      this.val = val;
      this.type = type;
    });
    Unit.prototype.__proto__ = Node.prototype;
    Unit.prototype.toBoolean = function() {
      return nodes.Boolean(this.type ? true : this.val);
    };
    Unit.prototype.toString = function() {
      return this.val + (this.type || '');
    };
    Unit.prototype.clone = function() {
      var clone = new Unit(this.val, this.type);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Unit.prototype.toJSON = function() {
      return {
        __type: 'Unit',
        val: this.val,
        type: this.type,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Unit.prototype.operate = function(op, right) {
      var type = this.type || right.first.type;
      if ('rgba' == right.nodeName || 'hsla' == right.nodeName) {
        return right.operate(op, this);
      }
      if (this.shouldCoerce(op)) {
        right = right.first;
        if ('%' != this.type && ('-' == op || '+' == op) && '%' == right.type) {
          right = new Unit(this.val * (right.val / 100), '%');
        } else {
          right = this.coerce(right);
        }
        switch (op) {
          case '-':
            return new Unit(this.val - right.val, type);
          case '+':
            type = type || (right.type == '%' && right.type);
            return new Unit(this.val + right.val, type);
          case '/':
            return new Unit(this.val / right.val, type);
          case '*':
            return new Unit(this.val * right.val, type);
          case '%':
            return new Unit(this.val % right.val, type);
          case '**':
            return new Unit(Math.pow(this.val, right.val), type);
          case '..':
          case '...':
            var start = this.val,
              end = right.val,
              expr = new nodes.Expression(),
              inclusive = '..' == op;
            if (start < end) {
              do {
                expr.push(new nodes.Unit(start));
              } while (inclusive ? ++start <= end : ++start < end);
            } else {
              do {
                expr.push(new nodes.Unit(start));
              } while (inclusive ? --start >= end : --start > end);
            }
            return expr;
        }
      }
      return Node.prototype.operate.call(this, op, right);
    };
    Unit.prototype.coerce = function(other) {
      if ('unit' == other.nodeName) {
        var a = this,
          b = other,
          factorA = FACTOR_TABLE[a.type],
          factorB = FACTOR_TABLE[b.type];
        if (factorA && factorB && factorA.label == factorB.label) {
          var bVal = b.val * (factorB.val / factorA.val);
          return new nodes.Unit(bVal, a.type);
        } else {
          return new nodes.Unit(b.val, a.type);
        }
      } else if ('string' == other.nodeName) {
        if ('%' == other.val) return new nodes.Unit(0, '%');
        var val = parseFloat(other.val);
        if (isNaN(val)) Node.prototype.coerce.call(this, other);
        return new nodes.Unit(val);
      } else {
        return Node.prototype.coerce.call(this, other);
      }
    };
  });
  require.register('nodes/object.js', function(module, exports, require) {
    var Node = require('./node'),
      nodes = require('./index'),
      nativeObj = {}.constructor;
    var Object = (module.exports = function Object() {
      Node.call(this);
      this.vals = {};
    });
    Object.prototype.__proto__ = Node.prototype;
    Object.prototype.set = function(key, val) {
      this.vals[key] = val;
      return this;
    };
    Object.prototype.__defineGetter__('length', function() {
      return nativeObj.keys(this.vals).length;
    });
    Object.prototype.get = function(key) {
      return this.vals[key] || nodes.nil;
    };
    Object.prototype.has = function(key) {
      return key in this.vals;
    };
    Object.prototype.operate = function(op, right) {
      switch (op) {
        case '.':
        case '[]':
          return this.get(right.hash);
        case '==':
          var vals = this.vals,
            a,
            b;
          if ('object' != right.nodeName || this.length != right.length)
            return nodes.no;
          for (var key in vals) {
            a = vals[key];
            b = right.vals[key];
            if (a.operate(op, b).isFalse) return nodes.no;
          }
          return nodes.yes;
        case '!=':
          return this.operate('==', right).negate();
        default:
          return Node.prototype.operate.call(this, op, right);
      }
    };
    Object.prototype.toBoolean = function() {
      return nodes.Boolean(this.length);
    };
    Object.prototype.toBlock = function() {
      var str = '{',
        key,
        val;
      for (key in this.vals) {
        val = this.get(key);
        if ('object' == val.first.nodeName) {
          str += key + ' ' + val.first.toBlock();
        } else {
          switch (key) {
            case '@charset':
              str += key + ' ' + val.first.toString() + ';';
              break;
            default:
              str += key + ':' + toString(val) + ';';
          }
        }
      }
      str += '}';
      return str;
      function toString(node) {
        if (node.nodes) {
          return node.nodes.map(toString).join(node.isList ? ',' : ' ');
        } else if ('literal' == node.nodeName && ',' == node.val) {
          return '\\,';
        }
        return node.toString();
      }
    };
    Object.prototype.clone = function(parent) {
      var clone = new Object();
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      for (var key in this.vals) {
        clone.vals[key] = this.vals[key].clone(parent, clone);
      }
      return clone;
    };
    Object.prototype.toJSON = function() {
      return {
        __type: 'Object',
        vals: this.vals,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Object.prototype.toString = function() {
      var obj = {};
      for (var prop in this.vals) {
        obj[prop] = this.vals[prop].toString();
      }
      return JSON.stringify(obj);
    };
  });
  require.register('nodes/supports.js', function(module, exports, require) {
    var Atrule = require('./atrule');
    var Supports = (module.exports = function Supports(condition) {
      Atrule.call(this, 'supports');
      this.condition = condition;
    });
    Supports.prototype.__proto__ = Atrule.prototype;
    Supports.prototype.clone = function(parent) {
      var clone = new Supports();
      clone.condition = this.condition.clone(parent, clone);
      clone.block = this.block.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Supports.prototype.toJSON = function() {
      return {
        __type: 'Supports',
        condition: this.condition,
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
    };
    Supports.prototype.toString = function() {
      return '@supports ' + this.condition;
    };
  });
  require.register('nodes/member.js', function(module, exports, require) {
    var Node = require('./node');
    var Member = (module.exports = function Member(left, right) {
      Node.call(this);
      this.left = left;
      this.right = right;
    });
    Member.prototype.__proto__ = Node.prototype;
    Member.prototype.clone = function(parent) {
      var clone = new Member();
      clone.left = this.left.clone(parent, clone);
      clone.right = this.right.clone(parent, clone);
      if (this.val) clone.val = this.val.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Member.prototype.toJSON = function() {
      var json = {
        __type: 'Member',
        left: this.left,
        right: this.right,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.val) json.val = this.val;
      return json;
    };
    Member.prototype.toString = function() {
      return this.left.toString() + '.' + this.right.toString();
    };
  });
  require.register('nodes/atblock.js', function(module, exports, require) {
    var Node = require('./node');
    var Atblock = (module.exports = function Atblock() {
      Node.call(this);
    });
    Atblock.prototype.__defineGetter__('nodes', function() {
      return this.block.nodes;
    });
    Atblock.prototype.__proto__ = Node.prototype;
    Atblock.prototype.clone = function(parent) {
      var clone = new Atblock();
      clone.block = this.block.clone(parent, clone);
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Atblock.prototype.toString = function() {
      return '@block';
    };
    Atblock.prototype.toJSON = function() {
      return {
        __type: 'Atblock',
        block: this.block,
        lineno: this.lineno,
        column: this.column,
        fileno: this.fileno,
      };
    };
  });
  require.register('nodes/atrule.js', function(module, exports, require) {
    var Node = require('./node');
    var Atrule = (module.exports = function Atrule(type) {
      Node.call(this);
      this.type = type;
    });
    Atrule.prototype.__proto__ = Node.prototype;
    Atrule.prototype.__defineGetter__('hasOnlyProperties', function() {
      if (!this.block) return false;
      var nodes = this.block.nodes;
      for (var i = 0, len = nodes.length; i < len; ++i) {
        var nodeName = nodes[i].nodeName;
        switch (nodes[i].nodeName) {
          case 'property':
          case 'expression':
          case 'comment':
            continue;
          default:
            return false;
        }
      }
      return true;
    });
    Atrule.prototype.clone = function(parent) {
      var clone = new Atrule(this.type);
      if (this.block) clone.block = this.block.clone(parent, clone);
      clone.segments = this.segments.map(function(node) {
        return node.clone(parent, clone);
      });
      clone.lineno = this.lineno;
      clone.column = this.column;
      clone.filename = this.filename;
      return clone;
    };
    Atrule.prototype.toJSON = function() {
      var json = {
        __type: 'Atrule',
        type: this.type,
        segments: this.segments,
        lineno: this.lineno,
        column: this.column,
        filename: this.filename,
      };
      if (this.block) json.block = this.block;
      return json;
    };
    Atrule.prototype.toString = function() {
      return '@' + this.type;
    };
    Atrule.prototype.__defineGetter__('hasOutput', function() {
      return !!this.block && hasOutput(this.block);
    });
    function hasOutput(block) {
      var nodes = block.nodes;
      if (
        nodes.every(function(node) {
          return 'group' == node.nodeName && node.hasOnlyPlaceholders;
        })
      )
        return false;
      return nodes.some(function(node) {
        switch (node.nodeName) {
          case 'property':
          case 'literal':
          case 'import':
            return true;
          case 'block':
            return hasOutput(node);
          default:
            if (node.block) return hasOutput(node.block);
        }
      });
    }
  });
  require.register('parser.js', function(module, exports, require) {
    var Lexer = require('./lexer'),
      nodes = require('./nodes'),
      Token = require('./token'),
      units = require('./units'),
      errors = require('./errors');
    var selectorTokens = [
      'ident',
      'string',
      'selector',
      'function',
      'comment',
      'boolean',
      'space',
      'color',
      'unit',
      'for',
      'in',
      '[',
      ']',
      '(',
      ')',
      '+',
      '-',
      '*',
      '*=',
      '<',
      '>',
      '=',
      ':',
      '&',
      '&&',
      '~',
      '{',
      '}',
      '.',
      '..',
      '/',
    ];
    var pseudoSelectors = [
      'matches',
      'not',
      'dir',
      'lang',
      'any-link',
      'link',
      'visited',
      'local-link',
      'target',
      'scope',
      'hover',
      'active',
      'focus',
      'drop',
      'current',
      'past',
      'future',
      'enabled',
      'disabled',
      'read-only',
      'read-write',
      'placeholder-shown',
      'checked',
      'indeterminate',
      'valid',
      'invalid',
      'in-range',
      'out-of-range',
      'required',
      'optional',
      'user-error',
      'root',
      'empty',
      'blank',
      'nth-child',
      'nth-last-child',
      'first-child',
      'last-child',
      'only-child',
      'nth-of-type',
      'nth-last-of-type',
      'first-of-type',
      'last-of-type',
      'only-of-type',
      'nth-match',
      'nth-last-match',
      'nth-column',
      'nth-last-column',
      'first-line',
      'first-letter',
      'before',
      'after',
      'selection',
    ];
    var Parser = (module.exports = function Parser(str, options) {
      var self = this;
      options = options || {};
      this.lexer = new Lexer(str, options);
      this.prefix = options.prefix || '';
      this.root = options.root || new nodes.Root();
      this.state = ['root'];
      this.stash = [];
      this.parens = 0;
      this.css = 0;
      this.state.pop = function() {
        self.prevState = [].pop.call(this);
      };
    });
    Parser.prototype = {
      constructor: Parser,
      currentState: function() {
        return this.state[this.state.length - 1];
      },
      previousState: function() {
        return this.state[this.state.length - 2];
      },
      parse: function() {
        var block = (this.parent = this.root);
        while ('eos' != this.peek().type) {
          this.skipWhitespace();
          if ('eos' == this.peek().type) break;
          var stmt = this.statement();
          this.accept(';');
          if (!stmt)
            this.error(
              'unexpected token {peek}, not allowed at the root level',
            );
          block.push(stmt);
        }
        return block;
      },
      error: function(msg) {
        var type = this.peek().type,
          val =
            undefined == this.peek().val ? '' : ' ' + this.peek().toString();
        if (val.trim() == type.trim()) val = '';
        throw new errors.ParseError(
          msg.replace('{peek}', '"' + type + val + '"'),
        );
      },
      accept: function(type) {
        if (type == this.peek().type) {
          return this.next();
        }
      },
      expect: function(type) {
        if (type != this.peek().type) {
          this.error('expected "' + type + '", got {peek}');
        }
        return this.next();
      },
      next: function() {
        var tok = this.stash.length ? this.stash.pop() : this.lexer.next(),
          line = tok.lineno,
          column = tok.column || 1;
        if (tok.val && tok.val.nodeName) {
          tok.val.lineno = line;
          tok.val.column = column;
        }
        nodes.lineno = line;
        nodes.column = column;
        return tok;
      },
      peek: function() {
        return this.lexer.peek();
      },
      lookahead: function(n) {
        return this.lexer.lookahead(n);
      },
      isSelectorToken: function(n) {
        var la = this.lookahead(n).type;
        switch (la) {
          case 'for':
            return this.bracketed;
          case '[':
            this.bracketed = true;
            return true;
          case ']':
            this.bracketed = false;
            return true;
          default:
            return ~selectorTokens.indexOf(la);
        }
      },
      isPseudoSelector: function(n) {
        var val = this.lookahead(n).val;
        return val && ~pseudoSelectors.indexOf(val.name);
      },
      lineContains: function(type) {
        var i = 1,
          la;
        while ((la = this.lookahead(i++))) {
          if (~['indent', 'outdent', 'newline', 'eos'].indexOf(la.type)) return;
          if (type == la.type) return true;
        }
      },
      selectorToken: function() {
        if (this.isSelectorToken(1)) {
          if ('{' == this.peek().type) {
            if (!this.lineContains('}')) return;
            var i = 0,
              la;
            while ((la = this.lookahead(++i))) {
              if ('}' == la.type) {
                if (i == 2 || (i == 3 && this.lookahead(i - 1).type == 'space'))
                  return;
                break;
              }
              if (':' == la.type) return;
            }
          }
          return this.next();
        }
      },
      skip: function(tokens) {
        while (~tokens.indexOf(this.peek().type)) this.next();
      },
      skipWhitespace: function() {
        this.skip(['space', 'indent', 'outdent', 'newline']);
      },
      skipNewlines: function() {
        while ('newline' == this.peek().type) this.next();
      },
      skipSpaces: function() {
        while ('space' == this.peek().type) this.next();
      },
      skipSpacesAndComments: function() {
        while ('space' == this.peek().type || 'comment' == this.peek().type)
          this.next();
      },
      looksLikeFunctionDefinition: function(i) {
        return (
          'indent' == this.lookahead(i).type || '{' == this.lookahead(i).type
        );
      },
      looksLikeSelector: function(fromProperty) {
        var i = 1,
          brace;
        if (
          fromProperty &&
          ':' == this.lookahead(i + 1).type &&
          (this.lookahead(i + 1).space ||
            'indent' == this.lookahead(i + 2).type)
        )
          return false;
        while (
          'ident' == this.lookahead(i).type &&
          ('newline' == this.lookahead(i + 1).type ||
            ',' == this.lookahead(i + 1).type)
        )
          i += 2;
        while (this.isSelectorToken(i) || ',' == this.lookahead(i).type) {
          if ('selector' == this.lookahead(i).type) return true;
          if ('&' == this.lookahead(i + 1).type) return true;
          if (
            '.' == this.lookahead(i).type &&
            'ident' == this.lookahead(i + 1).type
          )
            return true;
          if (
            '*' == this.lookahead(i).type &&
            'newline' == this.lookahead(i + 1).type
          )
            return true;
          if (
            ':' == this.lookahead(i).type &&
            ':' == this.lookahead(i + 1).type
          )
            return true;
          if (
            'color' == this.lookahead(i).type &&
            'newline' == this.lookahead(i - 1).type
          )
            return true;
          if (this.looksLikeAttributeSelector(i)) return true;
          if (
            ('=' == this.lookahead(i).type ||
              'function' == this.lookahead(i).type) &&
            '{' == this.lookahead(i + 1).type
          )
            return false;
          if (
            ':' == this.lookahead(i).type &&
            !this.isPseudoSelector(i + 1) &&
            this.lineContains('.')
          )
            return false;
          if ('{' == this.lookahead(i).type) brace = true;
          else if ('}' == this.lookahead(i).type) brace = false;
          if (brace && ':' == this.lookahead(i).type) return true;
          if (
            'space' == this.lookahead(i).type &&
            '{' == this.lookahead(i + 1).type
          )
            return true;
          if (
            ':' == this.lookahead(i++).type &&
            !this.lookahead(i - 1).space &&
            this.isPseudoSelector(i)
          )
            return true;
          if (
            'space' == this.lookahead(i).type &&
            'newline' == this.lookahead(i + 1).type &&
            '{' == this.lookahead(i + 2).type
          )
            return true;
          if (
            ',' == this.lookahead(i).type &&
            'newline' == this.lookahead(i + 1).type
          )
            return true;
        }
        if (
          ',' == this.lookahead(i).type &&
          'newline' == this.lookahead(i + 1).type
        )
          return true;
        if (
          '{' == this.lookahead(i).type &&
          'newline' == this.lookahead(i + 1).type
        )
          return true;
        if (this.css) {
          if (
            ';' == this.lookahead(i).type ||
            '}' == this.lookahead(i - 1).type
          )
            return false;
        }
        while (
          !~[
            'indent',
            'outdent',
            'newline',
            'for',
            'if',
            ';',
            '}',
            'eos',
          ].indexOf(this.lookahead(i).type)
        )
          ++i;
        if ('indent' == this.lookahead(i).type) return true;
      },
      looksLikeAttributeSelector: function(n) {
        var type = this.lookahead(n).type;
        if ('=' == type && this.bracketed) return true;
        return (
          ('ident' == type || 'string' == type) &&
          ']' == this.lookahead(n + 1).type &&
          ('newline' == this.lookahead(n + 2).type ||
            this.isSelectorToken(n + 2)) &&
          !this.lineContains(':') &&
          !this.lineContains('=')
        );
      },
      looksLikeKeyframe: function() {
        var i = 2,
          type;
        switch (this.lookahead(i).type) {
          case '{':
          case 'indent':
          case ',':
            return true;
          case 'newline':
            while (
              'unit' == this.lookahead(++i).type ||
              'newline' == this.lookahead(i).type
            );
            type = this.lookahead(i).type;
            return 'indent' == type || '{' == type;
        }
      },
      stateAllowsSelector: function() {
        switch (this.currentState()) {
          case 'root':
          case 'atblock':
          case 'selector':
          case 'conditional':
          case 'function':
          case 'atrule':
          case 'for':
            return true;
        }
      },
      assignAtblock: function(expr) {
        try {
          expr.push(this.atblock(expr));
        } catch (err) {
          this.error(
            'invalid right-hand side operand in assignment, got {peek}',
          );
        }
      },
      statement: function() {
        var stmt = this.stmt(),
          state = this.prevState,
          block,
          op;
        if (this.allowPostfix) {
          this.allowPostfix = false;
          state = 'expression';
        }
        switch (state) {
          case 'assignment':
          case 'expression':
          case 'function arguments':
            while (
              (op =
                this.accept('if') ||
                this.accept('unless') ||
                this.accept('for'))
            ) {
              switch (op.type) {
                case 'if':
                case 'unless':
                  stmt = new nodes.If(this.expression(), stmt);
                  stmt.postfix = true;
                  stmt.negate = 'unless' == op.type;
                  this.accept(';');
                  break;
                case 'for':
                  var key,
                    val = this.id().name;
                  if (this.accept(',')) key = this.id().name;
                  this.expect('in');
                  var each = new nodes.Each(val, key, this.expression());
                  block = new nodes.Block(this.parent, each);
                  block.push(stmt);
                  each.block = block;
                  stmt = each;
              }
            }
        }
        return stmt;
      },
      stmt: function() {
        var type = this.peek().type;
        switch (type) {
          case 'keyframes':
            return this.keyframes();
          case '-moz-document':
            return this.mozdocument();
          case 'comment':
          case 'selector':
          case 'extend':
          case 'literal':
          case 'charset':
          case 'namespace':
          case 'require':
          case 'extend':
          case 'media':
          case 'atrule':
          case 'ident':
          case 'scope':
          case 'supports':
          case 'unless':
            return this[type]();
          case 'function':
            return this.fun();
          case 'import':
            return this.atimport();
          case 'if':
            return this.ifstmt();
          case 'for':
            return this.forin();
          case 'return':
            return this.ret();
          case '{':
            return this.property();
          default:
            if (this.stateAllowsSelector()) {
              switch (type) {
                case 'color':
                case '~':
                case '>':
                case '<':
                case ':':
                case '&':
                case '&&':
                case '[':
                case '.':
                case '/':
                  return this.selector();
                case '..':
                  if ('/' == this.lookahead(2).type) return this.selector();
                case '+':
                  return 'function' == this.lookahead(2).type
                    ? this.functionCall()
                    : this.selector();
                case '*':
                  return this.property();
                case 'unit':
                  if (this.looksLikeKeyframe()) return this.selector();
                case '-':
                  if ('{' == this.lookahead(2).type) return this.property();
              }
            }
            var expr = this.expression();
            if (expr.isEmpty) this.error('unexpected {peek}');
            return expr;
        }
      },
      block: function(node, scope) {
        var delim,
          stmt,
          next,
          block = (this.parent = new nodes.Block(this.parent, node));
        if (false === scope) block.scope = false;
        this.accept('newline');
        if (this.accept('{')) {
          this.css++;
          delim = '}';
          this.skipWhitespace();
        } else {
          delim = 'outdent';
          this.expect('indent');
        }
        while (delim != this.peek().type) {
          if (this.css) {
            if (this.accept('newline') || this.accept('indent')) continue;
            stmt = this.statement();
            this.accept(';');
            this.skipWhitespace();
          } else {
            if (this.accept('newline')) continue;
            next = this.lookahead(2).type;
            if (
              'indent' == this.peek().type &&
              ~['outdent', 'newline', 'comment'].indexOf(next)
            ) {
              this.skip(['indent', 'outdent']);
              continue;
            }
            if ('eos' == this.peek().type) return block;
            stmt = this.statement();
            this.accept(';');
          }
          if (!stmt) this.error('unexpected token {peek} in block');
          block.push(stmt);
        }
        if (this.css) {
          this.skipWhitespace();
          this.expect('}');
          this.skipSpaces();
          this.css--;
        } else {
          this.expect('outdent');
        }
        this.parent = block.parent;
        return block;
      },
      comment: function() {
        var node = this.next().val;
        this.skipSpaces();
        return node;
      },
      forin: function() {
        this.expect('for');
        var key,
          val = this.id().name;
        if (this.accept(',')) key = this.id().name;
        this.expect('in');
        this.state.push('for');
        this.cond = true;
        var each = new nodes.Each(val, key, this.expression());
        this.cond = false;
        each.block = this.block(each, false);
        this.state.pop();
        return each;
      },
      ret: function() {
        this.expect('return');
        var expr = this.expression();
        return expr.isEmpty ? new nodes.Return() : new nodes.Return(expr);
      },
      unless: function() {
        this.expect('unless');
        this.state.push('conditional');
        this.cond = true;
        var node = new nodes.If(this.expression(), true);
        this.cond = false;
        node.block = this.block(node, false);
        this.state.pop();
        return node;
      },
      ifstmt: function() {
        this.expect('if');
        this.state.push('conditional');
        this.cond = true;
        var node = new nodes.If(this.expression()),
          cond,
          block;
        this.cond = false;
        node.block = this.block(node, false);
        this.skip(['newline', 'comment']);
        while (this.accept('else')) {
          if (this.accept('if')) {
            this.cond = true;
            cond = this.expression();
            this.cond = false;
            block = this.block(node, false);
            node.elses.push(new nodes.If(cond, block));
          } else {
            node.elses.push(this.block(node, false));
            break;
          }
          this.skip(['newline', 'comment']);
        }
        this.state.pop();
        return node;
      },
      atblock: function(node) {
        if (!node) this.expect('atblock');
        node = new nodes.Atblock();
        this.state.push('atblock');
        node.block = this.block(node, false);
        this.state.pop();
        return node;
      },
      atrule: function() {
        var type = this.expect('atrule').val,
          node = new nodes.Atrule(type),
          tok;
        this.skipSpacesAndComments();
        node.segments = this.selectorParts();
        this.skipSpacesAndComments();
        tok = this.peek().type;
        if (
          'indent' == tok ||
          '{' == tok ||
          ('newline' == tok && '{' == this.lookahead(2).type)
        ) {
          this.state.push('atrule');
          node.block = this.block(node);
          this.state.pop();
        }
        return node;
      },
      scope: function() {
        this.expect('scope');
        var selector = this.selectorParts()
          .map(function(selector) {
            return selector.val;
          })
          .join('');
        this.selectorScope = selector.trim();
        return nodes.nil;
      },
      supports: function() {
        this.expect('supports');
        var node = new nodes.Supports(this.supportsCondition());
        this.state.push('atrule');
        node.block = this.block(node);
        this.state.pop();
        return node;
      },
      supportsCondition: function() {
        var node = this.supportsNegation() || this.supportsOp();
        if (!node) {
          this.cond = true;
          node = this.expression();
          this.cond = false;
        }
        return node;
      },
      supportsNegation: function() {
        if (this.accept('not')) {
          var node = new nodes.Expression();
          node.push(new nodes.Literal('not'));
          node.push(this.supportsFeature());
          return node;
        }
      },
      supportsOp: function() {
        var feature = this.supportsFeature(),
          op,
          expr;
        if (feature) {
          expr = new nodes.Expression();
          expr.push(feature);
          while ((op = this.accept('&&') || this.accept('||'))) {
            expr.push(new nodes.Literal('&&' == op.val ? 'and' : 'or'));
            expr.push(this.supportsFeature());
          }
          return expr;
        }
      },
      supportsFeature: function() {
        this.skipSpacesAndComments();
        if ('(' == this.peek().type) {
          var la = this.lookahead(2).type;
          if ('ident' == la || '{' == la) {
            return this.feature();
          } else {
            this.expect('(');
            var node = new nodes.Expression();
            node.push(new nodes.Literal('('));
            node.push(this.supportsCondition());
            this.expect(')');
            node.push(new nodes.Literal(')'));
            this.skipSpacesAndComments();
            return node;
          }
        }
      },
      extend: function() {
        var tok = this.expect('extend'),
          selectors = [],
          sel,
          node,
          arr;
        do {
          arr = this.selectorParts();
          if (!arr.length) continue;
          sel = new nodes.Selector(arr);
          selectors.push(sel);
          if ('!' !== this.peek().type) continue;
          tok = this.lookahead(2);
          if ('ident' !== tok.type || 'optional' !== tok.val.name) continue;
          this.skip(['!', 'ident']);
          sel.optional = true;
        } while (this.accept(','));
        node = new nodes.Extend(selectors);
        node.lineno = tok.lineno;
        node.column = tok.column;
        return node;
      },
      media: function() {
        this.expect('media');
        this.state.push('atrule');
        var media = new nodes.Media(this.queries());
        media.block = this.block(media);
        this.state.pop();
        return media;
      },
      queries: function() {
        var queries = new nodes.QueryList(),
          skip = ['comment', 'newline', 'space'];
        do {
          this.skip(skip);
          queries.push(this.query());
          this.skip(skip);
        } while (this.accept(','));
        return queries;
      },
      query: function() {
        var query = new nodes.Query(),
          expr,
          pred,
          id;
        if (
          'ident' == this.peek().type &&
          ('.' == this.lookahead(2).type || '[' == this.lookahead(2).type)
        ) {
          this.cond = true;
          expr = this.expression();
          this.cond = false;
          query.push(new nodes.Feature(expr.nodes));
          return query;
        }
        if ((pred = this.accept('ident') || this.accept('not'))) {
          pred = new nodes.Literal(pred.val.string || pred.val);
          this.skipSpacesAndComments();
          if ((id = this.accept('ident'))) {
            query.type = id.val;
            query.predicate = pred;
          } else {
            query.type = pred;
          }
          this.skipSpacesAndComments();
          if (!this.accept('&&')) return query;
        }
        do {
          query.push(this.feature());
        } while (this.accept('&&'));
        return query;
      },
      feature: function() {
        this.skipSpacesAndComments();
        this.expect('(');
        this.skipSpacesAndComments();
        var node = new nodes.Feature(this.interpolate());
        this.skipSpacesAndComments();
        this.accept(':');
        this.skipSpacesAndComments();
        this.inProperty = true;
        node.expr = this.list();
        this.inProperty = false;
        this.skipSpacesAndComments();
        this.expect(')');
        this.skipSpacesAndComments();
        return node;
      },
      mozdocument: function() {
        this.expect('-moz-document');
        var mozdocument = new nodes.Atrule('-moz-document'),
          calls = [];
        do {
          this.skipSpacesAndComments();
          calls.push(this.functionCall());
          this.skipSpacesAndComments();
        } while (this.accept(','));
        mozdocument.segments = [new nodes.Literal(calls.join(', '))];
        this.state.push('atrule');
        mozdocument.block = this.block(mozdocument, false);
        this.state.pop();
        return mozdocument;
      },
      atimport: function() {
        this.expect('import');
        this.allowPostfix = true;
        return new nodes.Import(this.expression(), false);
      },
      require: function() {
        this.expect('require');
        this.allowPostfix = true;
        return new nodes.Import(this.expression(), true);
      },
      charset: function() {
        this.expect('charset');
        var str = this.expect('string').val;
        this.allowPostfix = true;
        return new nodes.Charset(str);
      },
      namespace: function() {
        var str, prefix;
        this.expect('namespace');
        this.skipSpacesAndComments();
        if ((prefix = this.accept('ident'))) {
          prefix = prefix.val;
        }
        this.skipSpacesAndComments();
        str = this.accept('string') || this.url();
        this.allowPostfix = true;
        return new nodes.Namespace(str, prefix);
      },
      keyframes: function() {
        var tok = this.expect('keyframes'),
          keyframes;
        this.skipSpacesAndComments();
        keyframes = new nodes.Keyframes(this.selectorParts(), tok.val);
        this.skipSpacesAndComments();
        this.state.push('atrule');
        keyframes.block = this.block(keyframes);
        this.state.pop();
        return keyframes;
      },
      literal: function() {
        return this.expect('literal').val;
      },
      id: function() {
        var tok = this.expect('ident');
        this.accept('space');
        return tok.val;
      },
      ident: function() {
        var i = 2,
          la = this.lookahead(i).type;
        while ('space' == la) la = this.lookahead(++i).type;
        switch (la) {
          case '=':
          case '?=':
          case '-=':
          case '+=':
          case '*=':
          case '/=':
          case '%=':
            return this.assignment();
          case '.':
            if ('space' == this.lookahead(i - 1).type) return this.selector();
            if (this._ident == this.peek()) return this.id();
            while (
              '=' != this.lookahead(++i).type &&
              !~['[', ',', 'newline', 'indent', 'eos'].indexOf(
                this.lookahead(i).type,
              )
            );
            if ('=' == this.lookahead(i).type) {
              this._ident = this.peek();
              return this.expression();
            } else if (this.looksLikeSelector() && this.stateAllowsSelector()) {
              return this.selector();
            }
          case '[':
            if (this._ident == this.peek()) return this.id();
            while (
              ']' != this.lookahead(i++).type &&
              'selector' != this.lookahead(i).type &&
              'eos' != this.lookahead(i).type
            );
            if ('=' == this.lookahead(i).type) {
              this._ident = this.peek();
              return this.expression();
            } else if (this.looksLikeSelector() && this.stateAllowsSelector()) {
              return this.selector();
            }
          case '-':
          case '+':
          case '/':
          case '*':
          case '%':
          case '**':
          case '&&':
          case '||':
          case '>':
          case '<':
          case '>=':
          case '<=':
          case '!=':
          case '==':
          case '?':
          case 'in':
          case 'is a':
          case 'is defined':
            if (this._ident == this.peek()) {
              return this.id();
            } else {
              this._ident = this.peek();
              switch (this.currentState()) {
                case 'for':
                case 'selector':
                  return this.property();
                case 'root':
                case 'atblock':
                case 'atrule':
                  return '[' == la ? this.subscript() : this.selector();
                case 'function':
                case 'conditional':
                  return this.looksLikeSelector()
                    ? this.selector()
                    : this.expression();
                default:
                  return this.operand ? this.id() : this.expression();
              }
            }
          default:
            switch (this.currentState()) {
              case 'root':
                return this.selector();
              case 'for':
              case 'selector':
              case 'function':
              case 'conditional':
              case 'atblock':
              case 'atrule':
                return this.property();
              default:
                var id = this.id();
                if ('interpolation' == this.previousState()) id.mixin = true;
                return id;
            }
        }
      },
      interpolate: function() {
        var node,
          segs = [],
          star;
        star = this.accept('*');
        if (star) segs.push(new nodes.Literal('*'));
        while (true) {
          if (this.accept('{')) {
            this.state.push('interpolation');
            segs.push(this.expression());
            this.expect('}');
            this.state.pop();
          } else if ((node = this.accept('-'))) {
            segs.push(new nodes.Literal('-'));
          } else if ((node = this.accept('ident'))) {
            segs.push(node.val);
          } else {
            break;
          }
        }
        if (!segs.length) this.expect('ident');
        return segs;
      },
      property: function() {
        if (this.looksLikeSelector(true)) return this.selector();
        var ident = this.interpolate(),
          prop = new nodes.Property(ident),
          ret = prop;
        this.accept('space');
        if (this.accept(':')) this.accept('space');
        this.state.push('property');
        this.inProperty = true;
        prop.expr = this.list();
        if (prop.expr.isEmpty) ret = ident[0];
        this.inProperty = false;
        this.allowPostfix = true;
        this.state.pop();
        this.accept(';');
        return ret;
      },
      selector: function() {
        var arr,
          group = new nodes.Group(),
          scope = this.selectorScope,
          isRoot = 'root' == this.currentState(),
          selector;
        do {
          this.accept('newline');
          arr = this.selectorParts();
          if (isRoot && scope) arr.unshift(new nodes.Literal(scope + ' '));
          if (arr.length) {
            selector = new nodes.Selector(arr);
            selector.lineno = arr[0].lineno;
            selector.column = arr[0].column;
            group.push(selector);
          }
        } while (this.accept(',') || this.accept('newline'));
        if ('selector-parts' == this.currentState()) return group.nodes;
        this.state.push('selector');
        group.block = this.block(group);
        this.state.pop();
        return group;
      },
      selectorParts: function() {
        var tok,
          arr = [];
        while ((tok = this.selectorToken())) {
          switch (tok.type) {
            case '{':
              this.skipSpaces();
              var expr = this.expression();
              this.skipSpaces();
              this.expect('}');
              arr.push(expr);
              break;
            case this.prefix && '.':
              var literal = new nodes.Literal(tok.val + this.prefix);
              literal.prefixed = true;
              arr.push(literal);
              break;
            case 'comment':
              break;
            case 'color':
            case 'unit':
              arr.push(new nodes.Literal(tok.val.raw));
              break;
            case 'space':
              arr.push(new nodes.Literal(' '));
              break;
            case 'function':
              arr.push(new nodes.Literal(tok.val.name + '('));
              break;
            case 'ident':
              arr.push(new nodes.Literal(tok.val.name || tok.val.string));
              break;
            default:
              arr.push(new nodes.Literal(tok.val));
              if (tok.space) arr.push(new nodes.Literal(' '));
          }
        }
        return arr;
      },
      assignment: function() {
        var op,
          node,
          name = this.id().name;
        if (
          (op =
            this.accept('=') ||
            this.accept('?=') ||
            this.accept('+=') ||
            this.accept('-=') ||
            this.accept('*=') ||
            this.accept('/=') ||
            this.accept('%='))
        ) {
          this.state.push('assignment');
          var expr = this.list();
          if (expr.isEmpty) this.assignAtblock(expr);
          node = new nodes.Ident(name, expr);
          this.state.pop();
          switch (op.type) {
            case '?=':
              var defined = new nodes.BinOp('is defined', node),
                lookup = new nodes.Expression();
              lookup.push(new nodes.Ident(name));
              node = new nodes.Ternary(defined, lookup, node);
              break;
            case '+=':
            case '-=':
            case '*=':
            case '/=':
            case '%=':
              node.val = new nodes.BinOp(
                op.type[0],
                new nodes.Ident(name),
                expr,
              );
              break;
          }
        }
        return node;
      },
      fun: function() {
        var parens = 1,
          i = 2,
          tok;
        out: while ((tok = this.lookahead(i++))) {
          switch (tok.type) {
            case 'function':
            case '(':
              ++parens;
              break;
            case ')':
              if (!--parens) break out;
              break;
            case 'eos':
              this.error('failed to find closing paren ")"');
          }
        }
        switch (this.currentState()) {
          case 'expression':
            return this.functionCall();
          default:
            return this.looksLikeFunctionDefinition(i)
              ? this.functionDefinition()
              : this.expression();
        }
      },
      url: function() {
        this.expect('function');
        this.state.push('function arguments');
        var args = this.args();
        this.expect(')');
        this.state.pop();
        return new nodes.Call('url', args);
      },
      functionCall: function() {
        var withBlock = this.accept('+');
        if ('url' == this.peek().val.name) return this.url();
        var name = this.expect('function').val.name;
        this.state.push('function arguments');
        this.parens++;
        var args = this.args();
        this.expect(')');
        this.parens--;
        this.state.pop();
        var call = new nodes.Call(name, args);
        if (withBlock) {
          this.state.push('function');
          call.block = this.block(call);
          this.state.pop();
        }
        return call;
      },
      functionDefinition: function() {
        var name = this.expect('function').val.name;
        this.state.push('function params');
        this.skipWhitespace();
        var params = this.params();
        this.skipWhitespace();
        this.expect(')');
        this.state.pop();
        this.state.push('function');
        var fn = new nodes.Function(name, params);
        fn.block = this.block(fn);
        this.state.pop();
        return new nodes.Ident(name, fn);
      },
      params: function() {
        var tok,
          node,
          params = new nodes.Params();
        while ((tok = this.accept('ident'))) {
          this.accept('space');
          params.push((node = tok.val));
          if (this.accept('...')) {
            node.rest = true;
          } else if (this.accept('=')) {
            node.val = this.expression();
          }
          this.skipWhitespace();
          this.accept(',');
          this.skipWhitespace();
        }
        return params;
      },
      args: function() {
        var args = new nodes.Arguments(),
          keyword;
        do {
          if ('ident' == this.peek().type && ':' == this.lookahead(2).type) {
            keyword = this.next().val.string;
            this.expect(':');
            args.map[keyword] = this.expression();
          } else {
            args.push(this.expression());
          }
        } while (this.accept(','));
        return args;
      },
      list: function() {
        var node = this.expression();
        while (this.accept(',')) {
          if (node.isList) {
            list.push(this.expression());
          } else {
            var list = new nodes.Expression(true);
            list.push(node);
            list.push(this.expression());
            node = list;
          }
        }
        return node;
      },
      expression: function() {
        var node,
          expr = new nodes.Expression();
        this.state.push('expression');
        while ((node = this.negation())) {
          if (!node) this.error('unexpected token {peek} in expression');
          expr.push(node);
        }
        this.state.pop();
        if (expr.nodes.length) {
          expr.lineno = expr.nodes[0].lineno;
          expr.column = expr.nodes[0].column;
        }
        return expr;
      },
      negation: function() {
        if (this.accept('not')) {
          return new nodes.UnaryOp('!', this.negation());
        }
        return this.ternary();
      },
      ternary: function() {
        var node = this.logical();
        if (this.accept('?')) {
          var trueExpr = this.expression();
          this.expect(':');
          var falseExpr = this.expression();
          node = new nodes.Ternary(node, trueExpr, falseExpr);
        }
        return node;
      },
      logical: function() {
        var op,
          node = this.typecheck();
        while ((op = this.accept('&&') || this.accept('||'))) {
          node = new nodes.BinOp(op.type, node, this.typecheck());
        }
        return node;
      },
      typecheck: function() {
        var op,
          node = this.equality();
        while ((op = this.accept('is a'))) {
          this.operand = true;
          if (!node)
            this.error('illegal unary "' + op + '", missing left-hand operand');
          node = new nodes.BinOp(op.type, node, this.equality());
          this.operand = false;
        }
        return node;
      },
      equality: function() {
        var op,
          node = this.inop();
        while ((op = this.accept('==') || this.accept('!='))) {
          this.operand = true;
          if (!node)
            this.error('illegal unary "' + op + '", missing left-hand operand');
          node = new nodes.BinOp(op.type, node, this.inop());
          this.operand = false;
        }
        return node;
      },
      inop: function() {
        var node = this.relational();
        while (this.accept('in')) {
          this.operand = true;
          if (!node)
            this.error('illegal unary "in", missing left-hand operand');
          node = new nodes.BinOp('in', node, this.relational());
          this.operand = false;
        }
        return node;
      },
      relational: function() {
        var op,
          node = this.range();
        while (
          (op =
            this.accept('>=') ||
            this.accept('<=') ||
            this.accept('<') ||
            this.accept('>'))
        ) {
          this.operand = true;
          if (!node)
            this.error('illegal unary "' + op + '", missing left-hand operand');
          node = new nodes.BinOp(op.type, node, this.range());
          this.operand = false;
        }
        return node;
      },
      range: function() {
        var op,
          node = this.additive();
        if ((op = this.accept('...') || this.accept('..'))) {
          this.operand = true;
          if (!node)
            this.error('illegal unary "' + op + '", missing left-hand operand');
          node = new nodes.BinOp(op.val, node, this.additive());
          this.operand = false;
        }
        return node;
      },
      additive: function() {
        var op,
          node = this.multiplicative();
        while ((op = this.accept('+') || this.accept('-'))) {
          this.operand = true;
          node = new nodes.BinOp(op.type, node, this.multiplicative());
          this.operand = false;
        }
        return node;
      },
      multiplicative: function() {
        var op,
          node = this.defined();
        while (
          (op =
            this.accept('**') ||
            this.accept('*') ||
            this.accept('/') ||
            this.accept('%'))
        ) {
          this.operand = true;
          if ('/' == op && this.inProperty && !this.parens) {
            this.stash.push(new Token('literal', new nodes.Literal('/')));
            this.operand = false;
            return node;
          } else {
            if (!node)
              this.error(
                'illegal unary "' + op + '", missing left-hand operand',
              );
            node = new nodes.BinOp(op.type, node, this.defined());
            this.operand = false;
          }
        }
        return node;
      },
      defined: function() {
        var node = this.unary();
        if (this.accept('is defined')) {
          if (!node)
            this.error('illegal unary "is defined", missing left-hand operand');
          node = new nodes.BinOp('is defined', node);
        }
        return node;
      },
      unary: function() {
        var op, node;
        if (
          (op =
            this.accept('!') ||
            this.accept('~') ||
            this.accept('+') ||
            this.accept('-'))
        ) {
          this.operand = true;
          node = this.unary();
          if (!node) this.error('illegal unary "' + op + '"');
          node = new nodes.UnaryOp(op.type, node);
          this.operand = false;
          return node;
        }
        return this.subscript();
      },
      subscript: function() {
        var node = this.member(),
          id;
        while (this.accept('[')) {
          node = new nodes.BinOp('[]', node, this.expression());
          this.expect(']');
        }
        if (this.accept('=')) {
          node.op += '=';
          node.val = this.list();
          if (node.val.isEmpty) this.assignAtblock(node.val);
        }
        return node;
      },
      member: function() {
        var node = this.primary();
        if (node) {
          while (this.accept('.')) {
            var id = new nodes.Ident(this.expect('ident').val.string);
            node = new nodes.Member(node, id);
          }
          this.skipSpaces();
          if (this.accept('=')) {
            node.val = this.list();
            if (node.val.isEmpty) this.assignAtblock(node.val);
          }
        }
        return node;
      },
      object: function() {
        var obj = new nodes.Object(),
          id,
          val,
          comma;
        this.expect('{');
        this.skipWhitespace();
        while (!this.accept('}')) {
          if (this.accept('comment') || this.accept('newline')) continue;
          if (!comma) this.accept(',');
          id = this.accept('ident') || this.accept('string');
          if (!id) this.error('expected "ident" or "string", got {peek}');
          id = id.val.hash;
          this.skipSpacesAndComments();
          this.expect(':');
          val = this.expression();
          obj.set(id, val);
          comma = this.accept(',');
          this.skipWhitespace();
        }
        return obj;
      },
      primary: function() {
        var tok;
        this.skipSpaces();
        if (this.accept('(')) {
          ++this.parens;
          var expr = this.expression(),
            paren = this.expect(')');
          --this.parens;
          if (this.accept('%')) expr.push(new nodes.Ident('%'));
          tok = this.peek();
          if (
            !paren.space &&
            'ident' == tok.type &&
            ~units.indexOf(tok.val.string)
          ) {
            expr.push(new nodes.Ident(tok.val.string));
            this.next();
          }
          return expr;
        }
        tok = this.peek();
        switch (tok.type) {
          case 'null':
          case 'unit':
          case 'color':
          case 'string':
          case 'literal':
          case 'boolean':
          case 'comment':
            return this.next().val;
          case !this.cond && '{':
            return this.object();
          case 'atblock':
            return this.atblock();
          case 'atrule':
            var id = new nodes.Ident(this.next().val);
            id.property = true;
            return id;
          case 'ident':
            return this.ident();
          case 'function':
            return tok.anonymous
              ? this.functionDefinition()
              : this.functionCall();
        }
      },
    };
  });
  require.register('renderer.js', function(module, exports, require) {
    var Parser = require('./parser'),
      Evaluator = require('./visitor/evaluator'),
      Normalizer = require('./visitor/normalizer'),
      utils = require('./utils'),
      nodes = require('./nodes'),
      join = require('./path').join;
    module.exports = Renderer;
    function Renderer(str, options) {
      options = options || {};
      options.globals = options.globals || {};
      options.functions = options.functions || {};
      options.use = options.use || [];
      options.use = Array.isArray(options.use) ? options.use : [options.use];
      options.imports = [];
      options.paths = options.paths || [];
      options.filename = options.filename || 'stylus';
      options.Evaluator = options.Evaluator || Evaluator;
      this.options = options;
      this.str = str;
    }
    Renderer.prototype.render = function(fn) {
      var parser = (this.parser = new Parser(this.str, this.options));
      for (var i = 0, len = this.options.use.length; i < len; i++) {
        this.use(this.options.use[i]);
      }
      try {
        nodes.filename = this.options.filename;
        var ast = parser.parse();
        this.evaluator = new this.options.Evaluator(ast, this.options);
        this.nodes = nodes;
        this.evaluator.renderer = this;
        ast = this.evaluator.evaluate();
        var normalizer = new Normalizer(ast, this.options);
        ast = normalizer.normalize();
        var compiler = this.options.sourcemap
            ? new (require('./visitor/sourcemapper'))(ast, this.options)
            : new (require('./visitor/compiler'))(ast, this.options),
          css = compiler.compile();
        if (this.options.sourcemap) this.sourcemap = compiler.map.toJSON();
      } catch (err) {
        var options = {};
        options.input = err.input || this.str;
        options.filename = err.filename || this.options.filename;
        options.lineno = err.lineno || parser.lexer.lineno;
        options.column = err.column || parser.lexer.column;
        if (!fn) throw utils.formatException(err, options);
        return fn(utils.formatException(err, options));
      }
      if (!fn) return css;
      fn(null, css);
    };
    Renderer.prototype.deps = function(filename) {
      var opts = utils.merge({ cache: false }, this.options);
      if (filename) opts.filename = filename;
      var DepsResolver = require('./visitor/deps-resolver'),
        parser = new Parser(this.str, opts);
      try {
        nodes.filename = opts.filename;
        var ast = parser.parse(),
          resolver = new DepsResolver(ast, opts);
        return resolver.resolve();
      } catch (err) {
        var options = {};
        options.input = err.input || this.str;
        options.filename = err.filename || opts.filename;
        options.lineno = err.lineno || parser.lexer.lineno;
        options.column = err.column || parser.lexer.column;
        throw utils.formatException(err, options);
      }
    };
    Renderer.prototype.set = function(key, val) {
      this.options[key] = val;
      return this;
    };
    Renderer.prototype.get = function(key) {
      return this.options[key];
    };
    Renderer.prototype.include = function(path) {
      this.options.paths.push(path);
      return this;
    };
    Renderer.prototype.use = function(fn) {
      fn.call(this, this);
      return this;
    };
    Renderer.prototype.define = function(name, fn, raw) {
      fn = utils.coerce(fn, raw);
      if (fn.nodeName) {
        this.options.globals[name] = fn;
        return this;
      }
      this.options.functions[name] = fn;
      if (undefined != raw) fn.raw = raw;
      return this;
    };
  });
  require.register('selector-parser.js', function(module, exports, require) {
    var COMBINATORS = ['>', '+', '~'];
    var SelectorParser = (module.exports = function SelectorParser(
      str,
      stack,
      parts,
    ) {
      this.str = str;
      this.stack = stack || [];
      this.parts = parts || [];
      this.pos = 0;
      this.level = 2;
      this.nested = true;
      this.ignore = false;
    });
    SelectorParser.prototype.skip = function(len) {
      this.str = this.str.substr(len);
      this.pos += len;
    };
    SelectorParser.prototype.skipSpaces = function() {
      while (' ' == this.str[0]) this.skip(1);
    };
    SelectorParser.prototype.advance = function() {
      return (
        this.root() ||
        this.relative() ||
        this.initial() ||
        this.escaped() ||
        this.parent() ||
        this.partial() ||
        this.char()
      );
    };
    SelectorParser.prototype.root = function() {
      if (!this.pos && '/' == this.str[0] && 'deep' != this.str.slice(1, 5)) {
        this.nested = false;
        this.skip(1);
      }
    };
    SelectorParser.prototype.relative = function(multi) {
      if ((!this.pos || multi) && '../' == this.str.slice(0, 3)) {
        this.nested = false;
        this.skip(3);
        while (this.relative(true)) this.level++;
        if (!this.raw) {
          var ret = this.stack[this.stack.length - this.level];
          if (ret) {
            return ret;
          } else {
            this.ignore = true;
          }
        }
      }
    };
    SelectorParser.prototype.initial = function() {
      if (!this.pos && '~' == this.str[0] && '/' == this.str[1]) {
        this.nested = false;
        this.skip(2);
        return this.stack[0];
      }
    };
    SelectorParser.prototype.escaped = function() {
      if ('\\' == this.str[0]) {
        var char = this.str[1];
        if ('&' == char || '^' == char) {
          this.skip(2);
          return char;
        }
      }
    };
    SelectorParser.prototype.parent = function() {
      if ('&' == this.str[0]) {
        this.nested = false;
        if (!this.pos && (!this.stack.length || this.raw)) {
          var i = 0;
          while (' ' == this.str[++i]);
          if (~COMBINATORS.indexOf(this.str[i])) {
            this.skip(i + 1);
            return;
          }
        }
        this.skip(1);
        if (!this.raw) return this.stack[this.stack.length - 1];
      }
    };
    SelectorParser.prototype.partial = function() {
      if ('^' == this.str[0] && '[' == this.str[1]) {
        this.skip(2);
        this.skipSpaces();
        var ret = this.range();
        this.skipSpaces();
        if (']' != this.str[0]) return '^[';
        this.nested = false;
        this.skip(1);
        if (ret) {
          return ret;
        } else {
          this.ignore = true;
        }
      }
    };
    SelectorParser.prototype.number = function() {
      var i = 0,
        ret = '';
      if ('-' == this.str[i]) ret += this.str[i++];
      while (this.str.charCodeAt(i) >= 48 && this.str.charCodeAt(i) <= 57)
        ret += this.str[i++];
      if (ret) {
        this.skip(i);
        return Number(ret);
      }
    };
    SelectorParser.prototype.range = function() {
      var start = this.number(),
        ret;
      if ('..' == this.str.slice(0, 2)) {
        this.skip(2);
        var end = this.number(),
          len = this.parts.length;
        if (start < 0) start = len + start - 1;
        if (end < 0) end = len + end - 1;
        if (start > end) {
          var tmp = start;
          start = end;
          end = tmp;
        }
        if (end < len - 1) {
          ret = this.parts
            .slice(start, end + 1)
            .map(function(part) {
              var selector = new SelectorParser(part, this.stack, this.parts);
              selector.raw = true;
              return selector.parse();
            }, this)
            .map(function(selector) {
              return (selector.nested ? ' ' : '') + selector.val;
            })
            .join('')
            .trim();
        }
      } else {
        ret = this.stack[start < 0 ? this.stack.length + start - 1 : start];
      }
      if (ret) {
        return ret;
      } else {
        this.ignore = true;
      }
    };
    SelectorParser.prototype.char = function() {
      var char = this.str[0];
      this.skip(1);
      return char;
    };
    SelectorParser.prototype.parse = function() {
      var val = '';
      while (this.str.length) {
        val += this.advance() || '';
        if (this.ignore) {
          val = '';
          break;
        }
      }
      return { val: val.trimRight(), nested: this.nested };
    };
  });
  require.register('stack/index.js', function(module, exports, require) {
    var Stack = (module.exports = function Stack() {
      Array.apply(this, arguments);
    });
    Stack.prototype.__proto__ = Array.prototype;
    Stack.prototype.push = function(frame) {
      frame.stack = this;
      frame.parent = this.currentFrame;
      return [].push.apply(this, arguments);
    };
    Stack.prototype.__defineGetter__('currentFrame', function() {
      return this[this.length - 1];
    });
    Stack.prototype.getBlockFrame = function(block) {
      for (var i = 0; i < this.length; ++i) {
        if (block == this[i].block) {
          return this[i];
        }
      }
    };
    Stack.prototype.lookup = function(name) {
      var block = this.currentFrame.block,
        val,
        ret;
      do {
        var frame = this.getBlockFrame(block);
        if (frame && (val = frame.lookup(name))) {
          return val;
        }
      } while ((block = block.parent));
    };
    Stack.prototype.inspect = function() {
      return this.reverse()
        .map(function(frame) {
          return frame.inspect();
        })
        .join('\n');
    };
    Stack.prototype.toString = function() {
      var block,
        node,
        buf = [],
        location,
        len = this.length;
      while (len--) {
        block = this[len].block;
        if ((node = block.node)) {
          location =
            '(' +
            node.filename +
            ':' +
            (node.lineno + 1) +
            ':' +
            node.column +
            ')';
          switch (node.nodeName) {
            case 'function':
              buf.push('    at ' + node.name + '() ' + location);
              break;
            case 'group':
              buf.push('    at "' + node.nodes[0].val + '" ' + location);
              break;
          }
        }
      }
      return buf.join('\n');
    };
  });
  require.register('stack/frame.js', function(module, exports, require) {
    var Scope = require('./scope');
    var Frame = (module.exports = function Frame(block) {
      this._scope = false === block.scope ? null : new Scope();
      this.block = block;
    });
    Frame.prototype.__defineGetter__('scope', function() {
      return this._scope || this.parent.scope;
    });
    Frame.prototype.lookup = function(name) {
      return this.scope.lookup(name);
    };
    Frame.prototype.inspect = function() {
      return (
        '[Frame ' +
        (false === this.block.scope ? 'scope-less' : this.scope.inspect()) +
        ']'
      );
    };
  });
  require.register('stack/scope.js', function(module, exports, require) {
    var Scope = (module.exports = function Scope() {
      this.locals = {};
    });
    Scope.prototype.add = function(ident) {
      this.locals[ident.name] = ident.val;
    };
    Scope.prototype.lookup = function(name) {
      return this.locals[name];
    };
    Scope.prototype.inspect = function() {
      var keys = Object.keys(this.locals).map(function(key) {
        return '@' + key;
      });
      return '[Scope' + (keys.length ? ' ' + keys.join(', ') : '') + ']';
    };
  });
  require.register('stylus.js', function(module, exports, require) {
    var Renderer = require('./renderer'),
      nodes = require('./nodes'),
      utils = require('./utils');
    exports = module.exports = render;
    exports.version = '0.54.5';
    exports.nodes = nodes;
    exports.functions = require('./functions');
    exports.utils = require('./utils');
    exports.Visitor = require('./visitor');
    exports.Parser = require('./parser');
    exports.Evaluator = require('./visitor/evaluator');
    exports.Normalizer = require('./visitor/normalizer');
    exports.Compiler = require('./visitor/compiler');
    exports.render = function(str, options, fn) {
      if ('function' == typeof options) (fn = options), (options = {});
      if (bifs) str = bifs + str;
      return new Renderer(str, options).render(fn);
    };
    function render(str, options) {
      if (bifs) str = bifs + str;
      return new Renderer(str, options);
    }
    exports.url = require('./functions/url');
  });
  require.register('token.js', function(module, exports, require) {
    var Token = (exports = module.exports = function Token(type, val) {
      this.type = type;
      this.val = val;
    });
    Token.prototype.inspect = function() {
      var val = ' ' + this.val;
      return (
        '[Token:' +
        this.lineno +
        ':' +
        this.column +
        ' ' +
        '' +
        this.type +
        '' +
        '' +
        (this.val ? val : '') +
        '' +
        ']'
      );
    };
    Token.prototype.toString = function() {
      return (undefined === this.val ? this.type : this.val).toString();
    };
  });
  require.register('utils.js', function(module, exports, require) {
    var nodes = require('./nodes'),
      join = require('./path').join,
      isAbsolute = require('./path').isAbsolute;
    exports.absolute =
      isAbsolute ||
      function(path) {
        return (
          path.substr(0, 2) == '\\\\' ||
          '/' === path.charAt(0) ||
          /^[a-z]:[\\\/]/i.test(path)
        );
      };
    exports.lookup = function(path, paths, ignore) {
      var lookup,
        i = paths.length;
      if (exports.absolute(path)) {
        try {
          return path;
        } catch (err) {}
      }
      while (i--) {
        try {
          lookup = join(paths[i], path);
          if (ignore == lookup) continue;
          return lookup;
        } catch (err) {}
      }
    };
    exports.find = function(path, paths, ignore) {
      var lookup,
        found,
        i = paths.length;
      if (exports.absolute(path)) {
        if ((found = glob.sync(path)).length) {
          return found;
        }
      }
      while (i--) {
        lookup = join(paths[i], path);
        if (ignore == lookup) continue;
        if ((found = glob.sync(lookup)).length) {
          return found;
        }
      }
    };
    exports.lookupIndex = function(name, paths, filename) {
      var found = exports.find(join(name, 'index.styl'), paths, filename);
      if (!found) {
        found = exports.find(
          join(name, basename(name).replace(/\.styl/i, '') + '.styl'),
          paths,
          filename,
        );
      }
      if (!found && !~name.indexOf('node_modules')) {
        found = lookupPackage(join('node_modules', name));
      }
      return found;
      function lookupPackage(dir) {
        var pkg = exports.lookup(join(dir, 'package.json'), paths, filename);
        if (!pkg) {
          return /\.styl$/i.test(dir)
            ? exports.lookupIndex(dir, paths, filename)
            : lookupPackage(dir + '.styl');
        }
        var main = require(relative(__dirname, pkg)).main;
        if (main) {
          found = exports.find(join(dir, main), paths, filename);
        } else {
          found = exports.lookupIndex(dir, paths, filename);
        }
        return found;
      }
    };
    exports.formatException = function(err, options) {
      var lineno = options.lineno,
        column = options.column,
        filename = options.filename,
        str = options.input,
        context = options.context || 8,
        context = context / 2,
        lines = ('\n' + str).split('\n'),
        start = Math.max(lineno - context, 1),
        end = Math.min(lines.length, lineno + context),
        pad = end.toString().length;
      var context = lines
        .slice(start, end)
        .map(function(line, i) {
          var curr = i + start;
          return (
            '   ' +
            Array(pad - curr.toString().length + 1).join(' ') +
            curr +
            '| ' +
            line +
            (curr == lineno
              ? '\n' +
                Array(curr.toString().length + 5 + column).join('-') +
                '^'
              : '')
          );
        })
        .join('\n');
      err.message =
        filename +
        ':' +
        lineno +
        ':' +
        column +
        '\n' +
        context +
        '\n\n' +
        err.message +
        '\n' +
        (err.stylusStack ? err.stylusStack + '\n' : '');
      if (err.fromStylus) err.stack = 'Error: ' + err.message;
      return err;
    };
    exports.assertType = function(node, type, param) {
      exports.assertPresent(node, param);
      if (node.nodeName == type) return;
      var actual = node.nodeName,
        msg =
          'expected ' +
          (param ? '"' + param + '" to be a ' : '') +
          type +
          ', but got ' +
          actual +
          ':' +
          node;
      throw new Error('TypeError: ' + msg);
    };
    exports.assertString = function(node, param) {
      exports.assertPresent(node, param);
      switch (node.nodeName) {
        case 'string':
        case 'ident':
        case 'literal':
          return;
        default:
          var actual = node.nodeName,
            msg =
              'expected string, ident or literal, but got ' +
              actual +
              ':' +
              node;
          throw new Error('TypeError: ' + msg);
      }
    };
    exports.assertColor = function(node, param) {
      exports.assertPresent(node, param);
      switch (node.nodeName) {
        case 'rgba':
        case 'hsla':
          return;
        default:
          var actual = node.nodeName,
            msg = 'expected rgba or hsla, but got ' + actual + ':' + node;
          throw new Error('TypeError: ' + msg);
      }
    };
    exports.assertPresent = function(node, name) {
      if (node) return;
      if (name) throw new Error('"' + name + '" argument required');
      throw new Error('argument missing');
    };
    exports.unwrap = function(expr) {
      if (expr.preserve) return expr;
      if ('arguments' != expr.nodeName && 'expression' != expr.nodeName)
        return expr;
      if (1 != expr.nodes.length) return expr;
      if (
        'arguments' != expr.nodes[0].nodeName &&
        'expression' != expr.nodes[0].nodeName
      )
        return expr;
      return exports.unwrap(expr.nodes[0]);
    };
    exports.coerce = function(val, raw) {
      switch (typeof val) {
        case 'function':
          return val;
        case 'string':
          return new nodes.String(val);
        case 'boolean':
          return new nodes.Boolean(val);
        case 'number':
          return new nodes.Unit(val);
        default:
          if (null == val) return nodes.nil;
          if (Array.isArray(val)) return exports.coerceArray(val, raw);
          if (val.nodeName) return val;
          return exports.coerceObject(val, raw);
      }
    };
    exports.coerceArray = function(val, raw) {
      var expr = new nodes.Expression();
      val.forEach(function(val) {
        expr.push(exports.coerce(val, raw));
      });
      return expr;
    };
    exports.coerceObject = function(obj, raw) {
      var node = raw ? new nodes.Object() : new nodes.Expression(),
        val;
      for (var key in obj) {
        val = exports.coerce(obj[key], raw);
        key = new nodes.Ident(key);
        if (raw) {
          node.set(key, val);
        } else {
          node.push(exports.coerceArray([key, val]));
        }
      }
      return node;
    };
    exports.params = function(fn) {
      return fn.toString().match(/\(([^)]*)\)/)[1].split(/ *, */);
    };
    exports.merge = function(a, b, deep) {
      for (var k in b) {
        if (deep && a[k]) {
          var nodeA = exports.unwrap(a[k]).first,
            nodeB = exports.unwrap(b[k]).first;
          if ('object' == nodeA.nodeName && 'object' == nodeB.nodeName) {
            a[k].first.vals = exports.merge(nodeA.vals, nodeB.vals, deep);
          } else {
            a[k] = b[k];
          }
        } else {
          a[k] = b[k];
        }
      }
      return a;
    };
    exports.uniq = function(arr) {
      var obj = {},
        ret = [];
      for (var i = 0, len = arr.length; i < len; ++i) {
        if (arr[i] in obj) continue;
        obj[arr[i]] = true;
        ret.push(arr[i]);
      }
      return ret;
    };
    exports.compileSelectors = function(arr, leaveHidden) {
      var selectors = [],
        Parser = require('./selector-parser'),
        indent = this.indent || '',
        buf = [];
      function parse(selector, buf) {
        var parts = [selector.val],
          str = new Parser(parts[0], parents, parts).parse().val,
          parents = [];
        if (buf.length) {
          for (var i = 0, len = buf.length; i < len; ++i) {
            parts.push(buf[i]);
            parents.push(str);
            var child = new Parser(buf[i], parents, parts).parse();
            if (child.nested) {
              str += ' ' + child.val;
            } else {
              str = child.val;
            }
          }
        }
        return str.trim();
      }
      function compile(arr, i) {
        if (i) {
          arr[i].forEach(function(selector) {
            if (!leaveHidden && selector.isPlaceholder) return;
            if (selector.inherits) {
              buf.unshift(selector.val);
              compile(arr, i - 1);
              buf.shift();
            } else {
              selectors.push(indent + parse(selector, buf));
            }
          });
        } else {
          arr[0].forEach(function(selector) {
            if (!leaveHidden && selector.isPlaceholder) return;
            var str = parse(selector, buf);
            if (str) selectors.push(indent + str);
          });
        }
      }
      compile(arr, arr.length - 1);
      return exports.uniq(selectors);
    };
    exports.parseString = function(str) {
      var Parser = require('./parser'),
        parser,
        ret;
      try {
        parser = new Parser(str);
        parser.state.push('expression');
        ret = new nodes.Expression();
        ret.nodes = parser.parse().nodes;
      } catch (e) {
        ret = new nodes.Literal(str);
      }
      return ret;
    };
  });
  require.register('visitor/index.js', function(module, exports, require) {
    var Visitor = (module.exports = function Visitor(root) {
      this.root = root;
    });
    Visitor.prototype.visit = function(node, fn) {
      var method = 'visit' + node.constructor.name;
      if (this[method]) return this[method](node);
      return node;
    };
  });
  require.register('visitor/compiler.js', function(module, exports, require) {
    var Visitor = require('./index'),
      utils = require('../utils');
    var Compiler = (module.exports = function Compiler(root, options) {
      options = options || {};
      this.compress = options.compress;
      this.firebug = options.firebug;
      this.linenos = options.linenos;
      this.spaces = options['indent spaces'] || 2;
      this.indents = 1;
      Visitor.call(this, root);
      this.stack = [];
    });
    Compiler.prototype.__proto__ = Visitor.prototype;
    Compiler.prototype.compile = function() {
      return this.visit(this.root);
    };
    Compiler.prototype.out = function(str, node) {
      return str;
    };
    Compiler.prototype.__defineGetter__('indent', function() {
      if (this.compress) return '';
      return new Array(this.indents).join(Array(this.spaces + 1).join(' '));
    });
    Compiler.prototype.needBrackets = function(node) {
      return (
        1 == this.indents || 'atrule' != node.nodeName || node.hasOnlyProperties
      );
    };
    Compiler.prototype.visitRoot = function(block) {
      this.buf = '';
      for (var i = 0, len = block.nodes.length; i < len; ++i) {
        var node = block.nodes[i];
        if (this.linenos || this.firebug) this.debugInfo(node);
        var ret = this.visit(node);
        if (ret) this.buf += this.out(ret + '\n', node);
      }
      return this.buf;
    };
    Compiler.prototype.visitBlock = function(block) {
      var node,
        separator = this.compress ? '' : '\n',
        needBrackets;
      if (block.hasProperties && !block.lacksRenderedSelectors) {
        needBrackets = this.needBrackets(block.node);
        if (needBrackets) {
          this.buf += this.out(this.compress ? '{' : ' {\n');
          ++this.indents;
        }
        for (var i = 0, len = block.nodes.length; i < len; ++i) {
          this.last = len - 1 == i;
          node = block.nodes[i];
          switch (node.nodeName) {
            case 'null':
            case 'expression':
            case 'function':
            case 'group':
            case 'block':
            case 'unit':
            case 'media':
            case 'keyframes':
            case 'atrule':
            case 'supports':
              continue;
            case !this.compress && node.inline && 'comment':
              this.buf = this.buf.slice(0, -1);
              this.buf += this.out(' ' + this.visit(node) + '\n', node);
              break;
            case 'property':
              var ret = this.visit(node) + separator;
              this.buf += this.compress ? ret : this.out(ret, node);
              break;
            default:
              this.buf += this.out(this.visit(node) + separator, node);
          }
        }
        if (needBrackets) {
          --this.indents;
          this.buf += this.out(this.indent + '}' + separator);
        }
      }
      for (var i = 0, len = block.nodes.length; i < len; ++i) {
        node = block.nodes[i];
        switch (node.nodeName) {
          case 'group':
          case 'block':
          case 'keyframes':
            if (this.linenos || this.firebug) this.debugInfo(node);
            this.visit(node);
            break;
          case 'media':
          case 'import':
          case 'atrule':
          case 'supports':
            this.visit(node);
            break;
          case 'comment':
            if (!node.suppress) {
              this.buf += this.out(this.indent + this.visit(node) + '\n', node);
            }
            break;
          case 'charset':
          case 'literal':
          case 'namespace':
            this.buf += this.out(this.visit(node) + '\n', node);
            break;
        }
      }
    };
    Compiler.prototype.visitKeyframes = function(node) {
      if (!node.frames) return;
      var prefix = 'official' == node.prefix ? '' : '-' + node.prefix + '-';
      this.buf += this.out(
        '@' +
          prefix +
          'keyframes ' +
          this.visit(node.val) +
          (this.compress ? '{' : ' {\n'),
        node,
      );
      this.keyframe = true;
      ++this.indents;
      this.visit(node.block);
      --this.indents;
      this.keyframe = false;
      this.buf += this.out('}' + (this.compress ? '' : '\n'));
    };
    Compiler.prototype.visitMedia = function(media) {
      var val = media.val;
      if (!media.hasOutput || !val.nodes.length) return;
      this.buf += this.out('@media ', media);
      this.visit(val);
      this.buf += this.out(this.compress ? '{' : ' {\n');
      ++this.indents;
      this.visit(media.block);
      --this.indents;
      this.buf += this.out('}' + (this.compress ? '' : '\n'));
    };
    Compiler.prototype.visitQueryList = function(queries) {
      for (var i = 0, len = queries.nodes.length; i < len; ++i) {
        this.visit(queries.nodes[i]);
        if (len - 1 != i)
          this.buf += this.out(',' + (this.compress ? '' : ' '));
      }
    };
    Compiler.prototype.visitQuery = function(node) {
      var len = node.nodes.length;
      if (node.predicate) this.buf += this.out(node.predicate + ' ');
      if (node.type) this.buf += this.out(node.type + (len ? ' and ' : ''));
      for (var i = 0; i < len; ++i) {
        this.buf += this.out(this.visit(node.nodes[i]));
        if (len - 1 != i) this.buf += this.out(' and ');
      }
    };
    Compiler.prototype.visitFeature = function(node) {
      if (!node.expr) {
        return node.name;
      } else if (node.expr.isEmpty) {
        return '(' + node.name + ')';
      } else {
        return (
          '(' +
          node.name +
          ':' +
          (this.compress ? '' : ' ') +
          this.visit(node.expr) +
          ')'
        );
      }
    };
    Compiler.prototype.visitImport = function(imported) {
      this.buf += this.out(
        '@import ' + this.visit(imported.path) + ';\n',
        imported,
      );
    };
    Compiler.prototype.visitAtrule = function(atrule) {
      var newline = this.compress ? '' : '\n';
      this.buf += this.out(this.indent + '@' + atrule.type, atrule);
      if (atrule.val) this.buf += this.out(' ' + atrule.val.trim());
      if (atrule.block) {
        if (atrule.hasOnlyProperties) {
          this.visit(atrule.block);
        } else {
          this.buf += this.out(this.compress ? '{' : ' {\n');
          ++this.indents;
          this.visit(atrule.block);
          --this.indents;
          this.buf += this.out(this.indent + '}' + newline);
        }
      } else {
        this.buf += this.out(';' + newline);
      }
    };
    (Compiler.prototype.visitSupports = function(node) {
      if (!node.hasOutput) return;
      this.buf += this.out(this.indent + '@supports ', node);
      this.isCondition = true;
      this.buf += this.out(this.visit(node.condition));
      this.isCondition = false;
      this.buf += this.out(this.compress ? '{' : ' {\n');
      ++this.indents;
      this.visit(node.block);
      --this.indents;
      this.buf += this.out(this.indent + '}' + (this.compress ? '' : '\n'));
    }), (Compiler.prototype.visitComment = function(comment) {
      return this.compress
        ? comment.suppress ? '' : comment.str
        : comment.str;
    });
    Compiler.prototype.visitFunction = function(fn) {
      return fn.name;
    };
    Compiler.prototype.visitCharset = function(charset) {
      return '@charset ' + this.visit(charset.val) + ';';
    };
    Compiler.prototype.visitNamespace = function(namespace) {
      return (
        '@namespace ' +
        (namespace.prefix ? this.visit(namespace.prefix) + ' ' : '') +
        this.visit(namespace.val) +
        ';'
      );
    };
    Compiler.prototype.visitLiteral = function(lit) {
      var val = lit.val;
      if (lit.css) val = val.replace(/^  /gm, '');
      return val;
    };
    Compiler.prototype.visitBoolean = function(bool) {
      return bool.toString();
    };
    Compiler.prototype.visitRGBA = function(rgba) {
      return rgba.toString();
    };
    Compiler.prototype.visitHSLA = function(hsla) {
      return hsla.rgba.toString();
    };
    Compiler.prototype.visitUnit = function(unit) {
      var type = unit.type || '',
        n = unit.val,
        float = n != (n | 0);
      if (this.compress) {
        if ('%' != type && 's' != type && 'ms' != type && 0 == n) return '0';
        if (float && n < 1 && n > -1) {
          return n.toString().replace('0.', '.') + type;
        }
      }
      return (float ? parseFloat(n.toFixed(15)) : n).toString() + type;
    };
    Compiler.prototype.visitGroup = function(group) {
      var stack = this.keyframe ? [] : this.stack,
        comma = this.compress ? ',' : ',\n';
      stack.push(group.nodes);
      if (group.block.hasProperties) {
        var selectors = utils.compileSelectors.call(this, stack),
          len = selectors.length;
        if (len) {
          if (this.keyframe) comma = this.compress ? ',' : ', ';
          for (var i = 0; i < len; ++i) {
            var selector = selectors[i],
              last = i == len - 1;
            if (this.keyframe) selector = i ? selector.trim() : selector;
            this.buf += this.out(
              selector + (last ? '' : comma),
              group.nodes[i],
            );
          }
        } else {
          group.block.lacksRenderedSelectors = true;
        }
      }
      this.visit(group.block);
      stack.pop();
    };
    Compiler.prototype.visitIdent = function(ident) {
      return ident.name;
    };
    Compiler.prototype.visitString = function(string) {
      return this.isURL ? string.val : string.toString();
    };
    Compiler.prototype.visitNull = function(node) {
      return '';
    };
    Compiler.prototype.visitCall = function(call) {
      this.isURL = 'url' == call.name;
      var args = call.args.nodes
        .map(function(arg) {
          return this.visit(arg);
        }, this)
        .join(this.compress ? ',' : ', ');
      if (this.isURL) args = '"' + args + '"';
      this.isURL = false;
      return call.name + '(' + args + ')';
    };
    Compiler.prototype.visitExpression = function(expr) {
      var buf = [],
        self = this,
        len = expr.nodes.length,
        nodes = expr.nodes.map(function(node) {
          return self.visit(node);
        });
      nodes.forEach(function(node, i) {
        var last = i == len - 1;
        buf.push(node);
        if ('/' == nodes[i + 1] || '/' == node) return;
        if (last) return;
        var space =
          self.isURL ||
          (self.isCondition && (')' == nodes[i + 1] || '(' == node))
            ? ''
            : ' ';
        buf.push(expr.isList ? (self.compress ? ',' : ', ') : space);
      });
      return buf.join('');
    };
    Compiler.prototype.visitArguments = Compiler.prototype.visitExpression;
    Compiler.prototype.visitProperty = function(prop) {
      var val = this.visit(prop.expr).trim(),
        name = prop.name || prop.segments.join(''),
        arr = [];
      arr.push(
        this.out(this.indent),
        this.out(name + (this.compress ? ':' : ': '), prop),
        this.out(val, prop.expr),
        this.out(this.compress ? (this.last ? '' : ';') : ';'),
      );
      return arr.join('');
    };
    Compiler.prototype.debugInfo = function(node) {
      var path =
          node.filename == 'stdin' ? 'stdin' : fs.realpathSync(node.filename),
        line =
          (node.nodes && node.nodes.length
            ? node.nodes[0].lineno
            : node.lineno) || 1;
      if (this.linenos) {
        this.buf += '\n/* ' + 'line ' + line + ' : ' + path + ' */\n';
      }
      if (this.firebug) {
        path =
          'file\\:\\/\\/' +
          path.replace(/([.:\/\\])/g, function(m) {
            return '\\' + (m === '\\' ? '/' : m);
          });
        line = '\\00003' + line;
        this.buf +=
          '\n@media -stylus-debug-info' +
          '{filename{font-family:' +
          path +
          '}line{font-family:' +
          line +
          '}}\n';
      }
    };
  });
  require.register('visitor/evaluator.js', function(module, exports, require) {
    var Visitor = require('./index'),
      nodes = require('../nodes'),
      Stack = require('../stack'),
      Frame = require('../stack/frame'),
      utils = require('../utils'),
      bifs = require('../functions'),
      dirname = require('../path').dirname,
      colors = require('../colors'),
      units = require('../units');
    function cloneNode(node) {
      if (node.block && node.block.node) {
        node.block.node = node.block.node.clone();
      }
      if (node.nodes && node.nodes.length) {
        node.nodes.map(cloneNode);
      }
      return node;
    }
    function importFile(node, file, literal) {
      var importStack = this.importStack,
        Parser = require('../parser'),
        stat;
      if (node.once) {
        if (this.requireHistory[file]) return nodes.nil;
        this.requireHistory[file] = true;
        if (literal && !this.includeCSS) {
          return node;
        }
      }
      if (~importStack.indexOf(file))
        throw new Error('import loop has been found');
      var str = fs.readFileSync(file, 'utf8');
      if (!str.trim()) return nodes.nil;
      node.path = file;
      node.dirname = dirname(file);
      stat = fs.statSync(file);
      node.mtime = stat.mtime;
      this.paths.push(node.dirname);
      if (this.options._imports) this.options._imports.push(node.clone());
      importStack.push(file);
      nodes.filename = file;
      if (literal) {
        literal = new nodes.Literal(str.replace(/\r\n?/g, '\n'));
        literal.lineno = literal.column = 1;
        if (!this.resolveURL) return literal;
      }
      var block = new nodes.Block(),
        parser = new Parser(str, utils.merge({ root: block }, this.options));
      try {
        block = parser.parse();
      } catch (err) {
        var line = parser.lexer.lineno,
          column = parser.lexer.column;
        if (literal && this.includeCSS && this.resolveURL) {
          this.warn(
            'ParseError: ' +
              file +
              ':' +
              line +
              ':' +
              column +
              '. This file included as-is',
          );
          return literal;
        } else {
          err.filename = file;
          err.lineno = line;
          err.column = column;
          err.input = str;
          throw err;
        }
      }
      block = block.clone(this.currentBlock);
      block.parent = this.currentBlock;
      block.scope = false;
      var ret = this.visit(block);
      importStack.pop();
      if (!this.resolveURL || this.resolveURL.nocheck) this.paths.pop();
      return ret;
    }
    var Evaluator = (module.exports = function Evaluator(root, options) {
      options = options || {};
      Visitor.call(this, root);
      var functions = (this.functions = options.functions || {});
      this.stack = new Stack();
      this.imports = options.imports || [];
      this.globals = options.globals || {};
      this.paths = options.paths || [];
      this.prefix = options.prefix || '';
      this.filename = options.filename;
      this.includeCSS = options['include css'];
      this.resolveURL =
        functions.url &&
        'resolver' == functions.url.name &&
        functions.url.options;
      this.paths.push(dirname(options.filename || '.'));
      this.stack.push((this.global = new Frame(root)));
      this.warnings = options.warn;
      this.options = options;
      this.calling = [];
      this.importStack = [];
      this.ret = 0;
      this.requireHistory = {};
    });
    Evaluator.prototype.__proto__ = Visitor.prototype;
    var visit = Visitor.prototype.visit;
    Evaluator.prototype.visit = function(node) {
      try {
        return visit.call(this, node);
      } catch (err) {
        if (err.filename) throw err;
        err.lineno = node.lineno;
        err.column = node.column;
        err.filename = node.filename;
        err.stylusStack = this.stack.toString();
        try {
        } catch (err) {}
        throw err;
      }
    };
    Evaluator.prototype.setup = function() {
      var root = this.root;
      var imports = [];
      this.populateGlobalScope();
      this.imports.forEach(function(file) {
        var expr = new nodes.Expression();
        expr.push(new nodes.String(file));
        imports.push(new nodes.Import(expr));
      }, this);
      root.nodes = imports.concat(root.nodes);
    };
    Evaluator.prototype.populateGlobalScope = function() {
      var scope = this.global.scope;
      Object.keys(colors).forEach(function(name) {
        var color = colors[name],
          rgba = new nodes.RGBA(color[0], color[1], color[2], color[3]),
          node = new nodes.Ident(name, rgba);
        rgba.name = name;
        scope.add(node);
      });
      scope.add(
        new nodes.Ident(
          'embedurl',
          new nodes.Function(
            'embedurl',
            require('../functions/url')({ limit: false }),
          ),
        ),
      );
      var globals = this.globals;
      Object.keys(globals).forEach(function(name) {
        var val = globals[name];
        if (!val.nodeName) val = new nodes.Literal(val);
        scope.add(new nodes.Ident(name, val));
      });
    };
    Evaluator.prototype.evaluate = function() {
      this.setup();
      return this.visit(this.root);
    };
    Evaluator.prototype.visitGroup = function(group) {
      group.nodes = group.nodes.map(function(selector) {
        selector.val = this.interpolate(selector);
        return selector;
      }, this);
      group.block = this.visit(group.block);
      return group;
    };
    Evaluator.prototype.visitReturn = function(ret) {
      ret.expr = this.visit(ret.expr);
      throw ret;
    };
    Evaluator.prototype.visitMedia = function(media) {
      media.block = this.visit(media.block);
      media.val = this.visit(media.val);
      return media;
    };
    Evaluator.prototype.visitQueryList = function(queries) {
      var val, query;
      queries.nodes.forEach(this.visit, this);
      if (1 == queries.nodes.length) {
        query = queries.nodes[0];
        if ((val = this.lookup(query.type))) {
          val = val.first.string;
          if (!val) return queries;
          var Parser = require('../parser'),
            parser = new Parser(val, this.options);
          queries = this.visit(parser.queries());
        }
      }
      return queries;
    };
    Evaluator.prototype.visitQuery = function(node) {
      node.predicate = this.visit(node.predicate);
      node.type = this.visit(node.type);
      node.nodes.forEach(this.visit, this);
      return node;
    };
    Evaluator.prototype.visitFeature = function(node) {
      node.name = this.interpolate(node);
      if (node.expr) {
        this.ret++;
        node.expr = this.visit(node.expr);
        this.ret--;
      }
      return node;
    };
    Evaluator.prototype.visitObject = function(obj) {
      for (var key in obj.vals) {
        obj.vals[key] = this.visit(obj.vals[key]);
      }
      return obj;
    };
    Evaluator.prototype.visitMember = function(node) {
      var left = node.left,
        right = node.right,
        obj = this.visit(left).first;
      if ('object' != obj.nodeName) {
        throw new Error(left.toString() + ' has no property .' + right);
      }
      if (node.val) {
        this.ret++;
        obj.set(right.name, this.visit(node.val));
        this.ret--;
      }
      return obj.get(right.name);
    };
    Evaluator.prototype.visitKeyframes = function(keyframes) {
      var val;
      if (keyframes.fabricated) return keyframes;
      keyframes.val = this.interpolate(keyframes).trim();
      if ((val = this.lookup(keyframes.val))) {
        keyframes.val = val.first.string || val.first.name;
      }
      keyframes.block = this.visit(keyframes.block);
      if ('official' != keyframes.prefix) return keyframes;
      this.vendors.forEach(function(prefix) {
        if ('ms' == prefix) return;
        var node = keyframes.clone();
        node.val = keyframes.val;
        node.prefix = prefix;
        node.block = keyframes.block;
        node.fabricated = true;
        this.currentBlock.push(node);
      }, this);
      return nodes.nil;
    };
    Evaluator.prototype.visitFunction = function(fn) {
      var local = this.stack.currentFrame.scope.lookup(fn.name);
      if (local)
        this.warn(
          'local ' +
            local.nodeName +
            ' "' +
            fn.name +
            '" previously defined in this scope',
        );
      var user = this.functions[fn.name];
      if (user)
        this.warn('user-defined function "' + fn.name + '" is already defined');
      var bif = bifs[fn.name];
      if (bif)
        this.warn('built-in function "' + fn.name + '" is already defined');
      return fn;
    };
    Evaluator.prototype.visitEach = function(each) {
      this.ret++;
      var expr = utils.unwrap(this.visit(each.expr)),
        len = expr.nodes.length,
        val = new nodes.Ident(each.val),
        key = new nodes.Ident(each.key || '__index__'),
        scope = this.currentScope,
        block = this.currentBlock,
        vals = [],
        self = this,
        body,
        obj;
      this.ret--;
      each.block.scope = false;
      function visitBody(key, val) {
        scope.add(val);
        scope.add(key);
        body = self.visit(each.block.clone());
        vals = vals.concat(body.nodes);
      }
      if (1 == len && 'object' == expr.nodes[0].nodeName) {
        obj = expr.nodes[0];
        for (var prop in obj.vals) {
          val.val = new nodes.String(prop);
          key.val = obj.get(prop);
          visitBody(key, val);
        }
      } else {
        for (var i = 0; i < len; ++i) {
          val.val = expr.nodes[i];
          key.val = new nodes.Unit(i);
          visitBody(key, val);
        }
      }
      this.mixin(vals, block);
      return vals[vals.length - 1] || nodes.nil;
    };
    Evaluator.prototype.visitCall = function(call) {
      var fn = this.lookup(call.name),
        literal,
        ret;
      this.ignoreColors = 'url' == call.name;
      if (fn && 'expression' == fn.nodeName) {
        fn = fn.nodes[0];
      }
      if (fn && 'function' != fn.nodeName) {
        fn = this.lookupFunction(call.name);
      }
      if (!fn || fn.nodeName != 'function') {
        if ('calc' == this.unvendorize(call.name)) {
          literal = call.args.nodes && call.args.nodes[0];
          if (literal) ret = new nodes.Literal(call.name + literal);
        } else {
          ret = this.literalCall(call);
        }
        this.ignoreColors = false;
        return ret;
      }
      this.calling.push(call.name);
      if (this.calling.length > 200) {
        throw new RangeError('Maximum stylus call stack size exceeded');
      }
      if ('expression' == fn.nodeName) fn = fn.first;
      this.ret++;
      var args = this.visit(call.args);
      for (var key in args.map) {
        args.map[key] = this.visit(args.map[key].clone());
      }
      this.ret--;
      if (fn.fn) {
        ret = this.invokeBuiltin(fn.fn, args);
      } else if ('function' == fn.nodeName) {
        if (call.block) call.block = this.visit(call.block);
        ret = this.invokeFunction(fn, args, call.block);
      }
      this.calling.pop();
      this.ignoreColors = false;
      return ret;
    };
    Evaluator.prototype.visitIdent = function(ident) {
      var prop;
      if (ident.property) {
        if ((prop = this.lookupProperty(ident.name))) {
          return this.visit(prop.expr.clone());
        }
        return nodes.nil;
      } else if (ident.val.isNull) {
        var val = this.lookup(ident.name);
        if (val && ident.mixin) this.mixinNode(val);
        return val ? this.visit(val) : ident;
      } else {
        this.ret++;
        ident.val = this.visit(ident.val);
        this.ret--;
        this.currentScope.add(ident);
        return ident.val;
      }
    };
    Evaluator.prototype.visitBinOp = function(binop) {
      if ('is defined' == binop.op) return this.isDefined(binop.left);
      this.ret++;
      var op = binop.op,
        left = this.visit(binop.left),
        right =
          '||' == op || '&&' == op ? binop.right : this.visit(binop.right);
      var val = binop.val ? this.visit(binop.val) : null;
      this.ret--;
      try {
        return this.visit(left.operate(op, right, val));
      } catch (err) {
        if ('CoercionError' == err.name) {
          switch (op) {
            case '==':
              return nodes.no;
            case '!=':
              return nodes.yes;
          }
        }
        throw err;
      }
    };
    Evaluator.prototype.visitUnaryOp = function(unary) {
      var op = unary.op,
        node = this.visit(unary.expr);
      if ('!' != op) {
        node = node.first.clone();
        utils.assertType(node, 'unit');
      }
      switch (op) {
        case '-':
          node.val = -node.val;
          break;
        case '+':
          node.val = +node.val;
          break;
        case '~':
          node.val = ~node.val;
          break;
        case '!':
          return node.toBoolean().negate();
      }
      return node;
    };
    Evaluator.prototype.visitTernary = function(ternary) {
      var ok = this.visit(ternary.cond).toBoolean();
      return ok.isTrue
        ? this.visit(ternary.trueExpr)
        : this.visit(ternary.falseExpr);
    };
    Evaluator.prototype.visitExpression = function(expr) {
      for (var i = 0, len = expr.nodes.length; i < len; ++i) {
        expr.nodes[i] = this.visit(expr.nodes[i]);
      }
      if (this.castable(expr)) expr = this.cast(expr);
      return expr;
    };
    Evaluator.prototype.visitArguments = Evaluator.prototype.visitExpression;
    Evaluator.prototype.visitProperty = function(prop) {
      var name = this.interpolate(prop),
        fn = this.lookup(name),
        call = fn && 'function' == fn.first.nodeName,
        literal = ~this.calling.indexOf(name),
        _prop = this.property;
      if (call && !literal && !prop.literal) {
        var args = nodes.Arguments.fromExpression(
          utils.unwrap(prop.expr.clone()),
        );
        prop.name = name;
        this.property = prop;
        this.ret++;
        this.property.expr = this.visit(prop.expr);
        this.ret--;
        var ret = this.visit(new nodes.Call(name, args));
        this.property = _prop;
        return ret;
      } else {
        this.ret++;
        prop.name = name;
        prop.literal = true;
        this.property = prop;
        prop.expr = this.visit(prop.expr);
        this.property = _prop;
        this.ret--;
        return prop;
      }
    };
    Evaluator.prototype.visitRoot = function(block) {
      if (block != this.root) {
        block.constructor = nodes.Block;
        return this.visit(block);
      }
      for (var i = 0; i < block.nodes.length; ++i) {
        block.index = i;
        block.nodes[i] = this.visit(block.nodes[i]);
      }
      return block;
    };
    Evaluator.prototype.visitBlock = function(block) {
      this.stack.push(new Frame(block));
      for (block.index = 0; block.index < block.nodes.length; ++block.index) {
        try {
          block.nodes[block.index] = this.visit(block.nodes[block.index]);
        } catch (err) {
          if ('return' == err.nodeName) {
            if (this.ret) {
              this.stack.pop();
              throw err;
            } else {
              block.nodes[block.index] = err;
              break;
            }
          } else {
            throw err;
          }
        }
      }
      this.stack.pop();
      return block;
    };
    Evaluator.prototype.visitAtblock = function(atblock) {
      atblock.block = this.visit(atblock.block);
      return atblock;
    };
    Evaluator.prototype.visitAtrule = function(atrule) {
      atrule.val = this.interpolate(atrule);
      if (atrule.block) atrule.block = this.visit(atrule.block);
      return atrule;
    };
    Evaluator.prototype.visitSupports = function(node) {
      var condition = node.condition,
        val;
      this.ret++;
      node.condition = this.visit(condition);
      this.ret--;
      val = condition.first;
      if (1 == condition.nodes.length && 'string' == val.nodeName) {
        node.condition = val.string;
      }
      node.block = this.visit(node.block);
      return node;
    };
    Evaluator.prototype.visitIf = function(node) {
      var ret,
        block = this.currentBlock,
        negate = node.negate;
      this.ret++;
      var ok = this.visit(node.cond).first.toBoolean();
      this.ret--;
      node.block.scope = node.block.hasMedia;
      if (negate) {
        if (ok.isFalse) {
          ret = this.visit(node.block);
        }
      } else {
        if (ok.isTrue) {
          ret = this.visit(node.block);
        } else if (node.elses.length) {
          var elses = node.elses,
            len = elses.length,
            cond;
          for (var i = 0; i < len; ++i) {
            if (elses[i].cond) {
              elses[i].block.scope = elses[i].block.hasMedia;
              this.ret++;
              cond = this.visit(elses[i].cond).first.toBoolean();
              this.ret--;
              if (cond.isTrue) {
                ret = this.visit(elses[i].block);
                break;
              }
            } else {
              elses[i].scope = elses[i].hasMedia;
              ret = this.visit(elses[i]);
            }
          }
        }
      }
      if (
        ret &&
        !node.postfix &&
        block.node &&
        ~['group', 'atrule', 'media', 'supports', 'keyframes'].indexOf(
          block.node.nodeName,
        )
      ) {
        this.mixin(ret.nodes, block);
        return nodes.nil;
      }
      return ret || nodes.nil;
    };
    Evaluator.prototype.visitExtend = function(extend) {
      var block = this.currentBlock;
      if ('group' != block.node.nodeName) block = this.closestGroup;
      extend.selectors.forEach(function(selector) {
        block.node.extends.push({
          selector: this.interpolate(selector.clone()).trim(),
          optional: selector.optional,
          lineno: selector.lineno,
          column: selector.column,
        });
      }, this);
      return nodes.nil;
    };
    Evaluator.prototype.visitImport = function(imported) {
      this.ret++;
      var path = this.visit(imported.path).first,
        nodeName = imported.once ? 'require' : 'import',
        found,
        literal;
      this.ret--;
      if ('url' == path.name) {
        if (imported.once) throw new Error('You cannot @require a url');
        return imported;
      }
      if (!path.string) throw new Error('@' + nodeName + ' string expected');
      var name = (path = path.string);
      if (/(?:url\s*\(\s*)?['"]?(?:#|(?:https?:)?\/\/)/i.test(path)) {
        if (imported.once) throw new Error('You cannot @require a url');
        return imported;
      }
      if (/\.css(?:"|$)/.test(path)) {
        literal = true;
        if (!imported.once && !this.includeCSS) {
          return imported;
        }
      }
      if (!literal && !/\.styl$/i.test(path)) path += '.styl';
      found = utils.find(path, this.paths, this.filename);
      if (!found) {
        found = utils.lookupIndex(name, this.paths, this.filename);
      }
      if (!found)
        throw new Error('failed to locate @' + nodeName + ' file ' + path);
      var block = new nodes.Block();
      for (var i = 0, len = found.length; i < len; ++i) {
        block.push(importFile.call(this, imported, found[i], literal));
      }
      return block;
    };
    Evaluator.prototype.invokeFunction = function(fn, args, content) {
      var block = new nodes.Block(fn.block.parent);
      var body = fn.block.clone(block);
      var mixinBlock = this.stack.currentFrame.block;
      this.stack.push(new Frame(block));
      var scope = this.currentScope;
      if ('arguments' != args.nodeName) {
        var expr = new nodes.Expression();
        expr.push(args);
        args = nodes.Arguments.fromExpression(expr);
      }
      scope.add(new nodes.Ident('arguments', args));
      scope.add(
        new nodes.Ident(
          'mixin',
          this.ret ? nodes.no : new nodes.String(mixinBlock.nodeName),
        ),
      );
      if (this.property) {
        var prop = this.propertyExpression(this.property, fn.name);
        scope.add(new nodes.Ident('current-property', prop));
      } else {
        scope.add(new nodes.Ident('current-property', nodes.nil));
      }
      var expr = new nodes.Expression();
      for (var i = this.calling.length - 1; i--; ) {
        expr.push(new nodes.Literal(this.calling[i]));
      }
      scope.add(new nodes.Ident('called-from', expr));
      var i = 0,
        len = args.nodes.length;
      fn.params.nodes.forEach(function(node) {
        if (node.rest) {
          node.val = new nodes.Expression();
          for (; i < len; ++i) node.val.push(args.nodes[i]);
          node.val.preserve = true;
          node.val.isList = args.isList;
        } else {
          var arg = args.map[node.name] || args.nodes[i++];
          node = node.clone();
          if (arg) {
            arg.isEmpty
              ? (args.nodes[i - 1] = this.visit(node))
              : (node.val = arg);
          } else {
            args.push(node.val);
          }
          if (node.val.isNull) {
            throw new Error('argument "' + node + '" required for ' + fn);
          }
        }
        scope.add(node);
      }, this);
      if (content) scope.add(new nodes.Ident('block', content, true));
      return this.invoke(body, true, fn.filename);
    };
    Evaluator.prototype.invokeBuiltin = function(fn, args) {
      if (fn.raw) {
        args = args.nodes;
      } else {
        args = utils.params(fn).reduce(function(ret, param) {
          var arg = args.map[param] || args.nodes.shift();
          if (arg) {
            arg = utils.unwrap(arg);
            var len = arg.nodes.length;
            if (len > 1) {
              for (var i = 0; i < len; ++i) {
                ret.push(utils.unwrap(arg.nodes[i].first));
              }
            } else {
              ret.push(arg.first);
            }
          }
          return ret;
        }, []);
      }
      var body = utils.coerce(fn.apply(this, args));
      var expr = new nodes.Expression();
      expr.push(body);
      body = expr;
      return this.invoke(body);
    };
    Evaluator.prototype.invoke = function(body, stack, filename) {
      var self = this,
        ret;
      if (filename) this.paths.push(dirname(filename));
      if (this.ret) {
        ret = this.eval(body.nodes);
        if (stack) this.stack.pop();
      } else {
        body = this.visit(body);
        if (stack) this.stack.pop();
        this.mixin(body.nodes, this.currentBlock);
        ret = nodes.nil;
      }
      if (filename) this.paths.pop();
      return ret;
    };
    Evaluator.prototype.mixin = function(nodes, block) {
      if (!nodes.length) return;
      var len = block.nodes.length,
        head = block.nodes.slice(0, block.index),
        tail = block.nodes.slice(block.index + 1, len);
      this._mixin(nodes, head, block);
      block.index = 0;
      block.nodes = head.concat(tail);
    };
    Evaluator.prototype._mixin = function(items, dest, block) {
      var node,
        len = items.length;
      for (var i = 0; i < len; ++i) {
        switch ((node = items[i]).nodeName) {
          case 'return':
            return;
          case 'block':
            this._mixin(node.nodes, dest, block);
            break;
          case 'media':
            var parentNode = node.block.parent.node;
            if (parentNode && 'call' != parentNode.nodeName) {
              node.block.parent = block;
            }
          case 'property':
            var val = node.expr;
            if (node.literal && 'block' == val.first.name) {
              val = utils.unwrap(val);
              val.nodes[0] = new nodes.Literal('block');
            }
          default:
            dest.push(node);
        }
      }
    };
    Evaluator.prototype.mixinNode = function(node) {
      node = this.visit(node.first);
      switch (node.nodeName) {
        case 'object':
          this.mixinObject(node);
          return nodes.nil;
        case 'block':
        case 'atblock':
          this.mixin(node.nodes, this.currentBlock);
          return nodes.nil;
      }
    };
    Evaluator.prototype.mixinObject = function(object) {
      var Parser = require('../parser'),
        root = this.root,
        str = '$block ' + object.toBlock(),
        parser = new Parser(str, utils.merge({ root: block }, this.options)),
        block;
      try {
        block = parser.parse();
      } catch (err) {
        err.filename = this.filename;
        err.lineno = parser.lexer.lineno;
        err.column = parser.lexer.column;
        err.input = str;
        throw err;
      }
      block.parent = root;
      block.scope = false;
      var ret = this.visit(block),
        vals = ret.first.nodes;
      for (var i = 0, len = vals.length; i < len; ++i) {
        if (vals[i].block) {
          this.mixin(vals[i].block.nodes, this.currentBlock);
          break;
        }
      }
    };
    Evaluator.prototype.eval = function(vals) {
      if (!vals) return nodes.nil;
      var len = vals.length,
        node = nodes.nil;
      try {
        for (var i = 0; i < len; ++i) {
          node = vals[i];
          switch (node.nodeName) {
            case 'if':
              if ('block' != node.block.nodeName) {
                node = this.visit(node);
                break;
              }
            case 'each':
            case 'block':
              node = this.visit(node);
              if (node.nodes) node = this.eval(node.nodes);
              break;
            default:
              node = this.visit(node);
          }
        }
      } catch (err) {
        if ('return' == err.nodeName) {
          return err.expr;
        } else {
          throw err;
        }
      }
      return node;
    };
    Evaluator.prototype.literalCall = function(call) {
      call.args = this.visit(call.args);
      return call;
    };
    Evaluator.prototype.lookupProperty = function(name) {
      var i = this.stack.length,
        index = this.currentBlock.index,
        top = i,
        nodes,
        block,
        len,
        other;
      while (i--) {
        block = this.stack[i].block;
        if (!block.node) continue;
        switch (block.node.nodeName) {
          case 'group':
          case 'function':
          case 'if':
          case 'each':
          case 'atrule':
          case 'media':
          case 'atblock':
          case 'call':
            nodes = block.nodes;
            if (i + 1 == top) {
              while (index--) {
                if (this.property == nodes[index]) continue;
                other = this.interpolate(nodes[index]);
                if (name == other) return nodes[index].clone();
              }
            } else {
              len = nodes.length;
              while (len--) {
                if (
                  'property' != nodes[len].nodeName ||
                  this.property == nodes[len]
                )
                  continue;
                other = this.interpolate(nodes[len]);
                if (name == other) return nodes[len].clone();
              }
            }
            break;
        }
      }
      return nodes.nil;
    };
    Evaluator.prototype.__defineGetter__('closestBlock', function() {
      var i = this.stack.length,
        block;
      while (i--) {
        block = this.stack[i].block;
        if (block.node) {
          switch (block.node.nodeName) {
            case 'group':
            case 'keyframes':
            case 'atrule':
            case 'atblock':
            case 'media':
            case 'call':
              return block;
          }
        }
      }
    });
    Evaluator.prototype.__defineGetter__('closestGroup', function() {
      var i = this.stack.length,
        block;
      while (i--) {
        block = this.stack[i].block;
        if (block.node && 'group' == block.node.nodeName) {
          return block;
        }
      }
    });
    Evaluator.prototype.__defineGetter__('selectorStack', function() {
      var block,
        stack = [];
      for (var i = 0, len = this.stack.length; i < len; ++i) {
        block = this.stack[i].block;
        if (block.node && 'group' == block.node.nodeName) {
          block.node.nodes.forEach(function(selector) {
            if (!selector.val) selector.val = this.interpolate(selector);
          }, this);
          stack.push(block.node.nodes);
        }
      }
      return stack;
    });
    Evaluator.prototype.lookup = function(name) {
      var val;
      if (this.ignoreColors && name in colors) return;
      if ((val = this.stack.lookup(name))) {
        return utils.unwrap(val);
      } else {
        return this.lookupFunction(name);
      }
    };
    Evaluator.prototype.interpolate = function(node) {
      var self = this,
        isSelector = 'selector' == node.nodeName;
      function toString(node) {
        switch (node.nodeName) {
          case 'function':
          case 'ident':
            return node.name;
          case 'literal':
          case 'string':
            if (self.prefix && !node.prefixed && !node.val.nodeName) {
              node.val = node.val.replace(/\./g, '.' + self.prefix);
              node.prefixed = true;
            }
            return node.val;
          case 'unit':
            return '%' == node.type ? node.val + '%' : node.val;
          case 'member':
            return toString(self.visit(node));
          case 'expression':
            if (
              self.calling &&
              ~self.calling.indexOf('selector') &&
              self._selector
            )
              return self._selector;
            self.ret++;
            var ret = toString(self.visit(node).first);
            self.ret--;
            if (isSelector) self._selector = ret;
            return ret;
        }
      }
      if (node.segments) {
        return node.segments.map(toString).join('');
      } else {
        return toString(node);
      }
    };
    Evaluator.prototype.lookupFunction = function(name) {
      var fn = this.functions[name] || bifs[name];
      if (fn) return new nodes.Function(name, fn);
    };
    Evaluator.prototype.isDefined = function(node) {
      if ('ident' == node.nodeName) {
        return nodes.Boolean(this.lookup(node.name));
      } else {
        throw new Error('invalid "is defined" check on non-variable ' + node);
      }
    };
    Evaluator.prototype.propertyExpression = function(prop, name) {
      var expr = new nodes.Expression(),
        val = prop.expr.clone();
      expr.push(new nodes.String(prop.name));
      function replace(node) {
        if ('call' == node.nodeName && name == node.name) {
          return new nodes.Literal('__CALL__');
        }
        if (node.nodes) node.nodes = node.nodes.map(replace);
        return node;
      }
      replace(val);
      expr.push(val);
      return expr;
    };
    Evaluator.prototype.cast = function(expr) {
      return new nodes.Unit(expr.first.val, expr.nodes[1].name);
    };
    Evaluator.prototype.castable = function(expr) {
      return (
        2 == expr.nodes.length &&
        'unit' == expr.first.nodeName &&
        ~units.indexOf(expr.nodes[1].name)
      );
    };
    Evaluator.prototype.warn = function(msg) {
      if (!this.warnings) return;
      console.warn('Warning: ' + msg);
    };
    Evaluator.prototype.__defineGetter__('currentBlock', function() {
      return this.stack.currentFrame.block;
    });
    Evaluator.prototype.__defineGetter__('vendors', function() {
      return this.lookup('vendors').nodes.map(function(node) {
        return node.string;
      });
    });
    Evaluator.prototype.unvendorize = function(prop) {
      for (var i = 0, len = this.vendors.length; i < len; i++) {
        if ('official' != this.vendors[i]) {
          var vendor = '-' + this.vendors[i] + '-';
          if (~prop.indexOf(vendor)) return prop.replace(vendor, '');
        }
      }
      return prop;
    };
    Evaluator.prototype.__defineGetter__('currentScope', function() {
      return this.stack.currentFrame.scope;
    });
    Evaluator.prototype.__defineGetter__('currentFrame', function() {
      return this.stack.currentFrame;
    });
  });
  require.register('visitor/normalizer.js', function(module, exports, require) {
    var Visitor = require('./index'),
      nodes = require('../nodes/index'),
      utils = require('../utils');
    var Normalizer = (module.exports = function Normalizer(root, options) {
      options = options || {};
      Visitor.call(this, root);
      this.hoist = options['hoist atrules'];
      this.stack = [];
      this.map = {};
      this.imports = [];
    });
    Normalizer.prototype.__proto__ = Visitor.prototype;
    Normalizer.prototype.normalize = function() {
      var ret = this.visit(this.root);
      if (this.hoist) {
        if (this.imports.length) ret.nodes = this.imports.concat(ret.nodes);
        if (this.charset) ret.nodes = [this.charset].concat(ret.nodes);
      }
      return ret;
    };
    Normalizer.prototype.bubble = function(node) {
      var props = [],
        other = [],
        self = this;
      function filterProps(block) {
        block.nodes.forEach(function(node) {
          node = self.visit(node);
          switch (node.nodeName) {
            case 'property':
              props.push(node);
              break;
            case 'block':
              filterProps(node);
              break;
            default:
              other.push(node);
          }
        });
      }
      filterProps(node.block);
      if (props.length) {
        var selector = new nodes.Selector([new nodes.Literal('&')]);
        selector.lineno = node.lineno;
        selector.column = node.column;
        selector.filename = node.filename;
        selector.val = '&';
        var group = new nodes.Group();
        group.lineno = node.lineno;
        group.column = node.column;
        group.filename = node.filename;
        var block = new nodes.Block(node.block, group);
        block.lineno = node.lineno;
        block.column = node.column;
        block.filename = node.filename;
        props.forEach(function(prop) {
          block.push(prop);
        });
        group.push(selector);
        group.block = block;
        node.block.nodes = [];
        node.block.push(group);
        other.forEach(function(n) {
          node.block.push(n);
        });
        var group = this.closestGroup(node.block);
        if (group) node.group = group.clone();
        node.bubbled = true;
      }
    };
    Normalizer.prototype.closestGroup = function(block) {
      var parent = block.parent,
        node;
      while (parent && (node = parent.node)) {
        if ('group' == node.nodeName) return node;
        parent = node.block && node.block.parent;
      }
    };
    Normalizer.prototype.visitRoot = function(block) {
      var ret = new nodes.Root(),
        node;
      for (var i = 0; i < block.nodes.length; ++i) {
        node = block.nodes[i];
        switch (node.nodeName) {
          case 'null':
          case 'expression':
          case 'function':
          case 'unit':
          case 'atblock':
            continue;
          default:
            this.rootIndex = i;
            ret.push(this.visit(node));
        }
      }
      return ret;
    };
    Normalizer.prototype.visitProperty = function(prop) {
      this.visit(prop.expr);
      return prop;
    };
    Normalizer.prototype.visitExpression = function(expr) {
      expr.nodes = expr.nodes.map(function(node) {
        if ('block' == node.nodeName) {
          var literal = new nodes.Literal('block');
          literal.lineno = expr.lineno;
          literal.column = expr.column;
          return literal;
        }
        return node;
      });
      return expr;
    };
    Normalizer.prototype.visitBlock = function(block) {
      var node;
      if (block.hasProperties) {
        for (var i = 0, len = block.nodes.length; i < len; ++i) {
          node = block.nodes[i];
          switch (node.nodeName) {
            case 'null':
            case 'expression':
            case 'function':
            case 'group':
            case 'unit':
            case 'atblock':
              continue;
            default:
              block.nodes[i] = this.visit(node);
          }
        }
      }
      for (var i = 0, len = block.nodes.length; i < len; ++i) {
        node = block.nodes[i];
        block.nodes[i] = this.visit(node);
      }
      return block;
    };
    Normalizer.prototype.visitGroup = function(group) {
      var stack = this.stack,
        map = this.map,
        parts;
      group.nodes.forEach(function(selector, i) {
        if (!~selector.val.indexOf(',')) return;
        if (~selector.val.indexOf('\\,')) {
          selector.val = selector.val.replace(/\\,/g, ',');
          return;
        }
        parts = selector.val.split(',');
        var root = '/' == selector.val.charAt(0),
          part,
          s;
        for (var k = 0, len = parts.length; k < len; ++k) {
          part = parts[k].trim();
          if (root && k > 0 && !~part.indexOf('&')) {
            part = '/' + part;
          }
          s = new nodes.Selector([new nodes.Literal(part)]);
          s.val = part;
          s.block = group.block;
          group.nodes[i++] = s;
        }
      });
      stack.push(group.nodes);
      var selectors = utils.compileSelectors(stack, true);
      selectors.forEach(function(selector) {
        map[selector] = map[selector] || [];
        map[selector].push(group);
      });
      this.extend(group, selectors);
      stack.pop();
      return group;
    };
    Normalizer.prototype.visitFunction = function() {
      return nodes.nil;
    };
    Normalizer.prototype.visitMedia = function(media) {
      var medias = [],
        group = this.closestGroup(media.block),
        parent;
      function mergeQueries(block) {
        block.nodes.forEach(function(node, i) {
          switch (node.nodeName) {
            case 'media':
              node.val = media.val.merge(node.val);
              medias.push(node);
              block.nodes[i] = nodes.nil;
              break;
            case 'block':
              mergeQueries(node);
              break;
            default:
              if (node.block && node.block.nodes) mergeQueries(node.block);
          }
        });
      }
      mergeQueries(media.block);
      this.bubble(media);
      if (medias.length) {
        medias.forEach(function(node) {
          if (group) {
            group.block.push(node);
          } else {
            this.root.nodes.splice(++this.rootIndex, 0, node);
          }
          node = this.visit(node);
          parent = node.block.parent;
          if (node.bubbled && (!group || 'group' == parent.node.nodeName)) {
            node.group.block = node.block.nodes[0].block;
            node.block.nodes[0] = node.group;
          }
        }, this);
      }
      return media;
    };
    Normalizer.prototype.visitSupports = function(node) {
      this.bubble(node);
      return node;
    };
    Normalizer.prototype.visitAtrule = function(node) {
      if (node.block) node.block = this.visit(node.block);
      return node;
    };
    Normalizer.prototype.visitKeyframes = function(node) {
      var frames = node.block.nodes.filter(function(frame) {
        return frame.block && frame.block.hasProperties;
      });
      node.frames = frames.length;
      return node;
    };
    Normalizer.prototype.visitImport = function(node) {
      this.imports.push(node);
      return this.hoist ? nodes.nil : node;
    };
    Normalizer.prototype.visitCharset = function(node) {
      this.charset = node;
      return this.hoist ? nodes.nil : node;
    };
    Normalizer.prototype.extend = function(group, selectors) {
      var map = this.map,
        self = this,
        parent = this.closestGroup(group.block);
      group.extends.forEach(function(extend) {
        var groups = map[extend.selector];
        if (!groups) {
          if (extend.optional) return;
          var err = new Error('Failed to @extend "' + extend.selector + '"');
          err.lineno = extend.lineno;
          err.column = extend.column;
          throw err;
        }
        selectors.forEach(function(selector) {
          var node = new nodes.Selector();
          node.val = selector;
          node.inherits = false;
          groups.forEach(function(group) {
            if (!parent || parent != group) self.extend(group, selectors);
            group.push(node);
          });
        });
      });
      group.block = this.visit(group.block);
    };
  });
  return require('stylus');
})();