text: 
  
  /* **********************************************
       Begin less-1.3.3.js
  ********************************************** */
  
  //
  // LESS - Leaner CSS v1.3.3
  // http://lesscss.org
  // 
  // Copyright (c) 2009-2013, Alexis Sellier
  // Licensed under the Apache 2.0 License.
  //
  (function (window, undefined) {
  //
  // Stub out `require` in the browser
  //
  function require(arg) {
      return window.less[arg.split('/')[1]];
  };
  
  
  // ecma-5.js
  //
  // -- kriskowal Kris Kowal Copyright (C) 2009-2010 MIT License
  // -- tlrobinson Tom Robinson
  // dantman Daniel Friesen
  
  //
  // Array
  //
  if (!Array.isArray) {
      Array.isArray = function(obj) {
          return Object.prototype.toString.call(obj) === "[object Array]" ||
                 (obj instanceof Array);
      };
  }
  if (!Array.prototype.forEach) {
      Array.prototype.forEach =  function(block, thisObject) {
          var len = this.length >>> 0;
          for (var i = 0; i < len; i++) {
              if (i in this) {
                  block.call(thisObject, this[i], i, this);
              }
          }
      };
  }
  if (!Array.prototype.map) {
      Array.prototype.map = function(fun /*, thisp*/) {
          var len = this.length >>> 0;
          var res = new Array(len);
          var thisp = arguments[1];
  
          for (var i = 0; i < len; i++) {
              if (i in this) {
                  res[i] = fun.call(thisp, this[i], i, this);
              }
          }
          return res;
      };
  }
  if (!Array.prototype.filter) {
      Array.prototype.filter = function (block /*, thisp */) {
          var values = [];
          var thisp = arguments[1];
          for (var i = 0; i < this.length; i++) {
              if (block.call(thisp, this[i])) {
                  values.push(this[i]);
              }
          }
          return values;
      };
  }
  if (!Array.prototype.reduce) {
      Array.prototype.reduce = function(fun /*, initial*/) {
          var len = this.length >>> 0;
          var i = 0;
  
          // no value to return if no initial value and an empty array
          if (len === 0 && arguments.length === 1) throw new TypeError();
  
          if (arguments.length >= 2) {
              var rv = arguments[1];
          } else {
              do {
                  if (i in this) {
                      rv = this[i++];
                      break;
                  }
                  // if array contains no values, no initial value to return
                  if (++i >= len) throw new TypeError();
              } while (true);
          }
          for (; i < len; i++) {
              if (i in this) {
                  rv = fun.call(null, rv, this[i], i, this);
              }
          }
          return rv;
      };
  }
  if (!Array.prototype.indexOf) {
      Array.prototype.indexOf = function (value /*, fromIndex */ ) {
          var length = this.length;
          var i = arguments[1] || 0;
  
          if (!length)     return -1;
          if (i >= length) return -1;
          if (i < 0)       i += length;
  
          for (; i < length; i++) {
              if (!Object.prototype.hasOwnProperty.call(this, i)) { continue }
              if (value === this[i]) return i;
          }
          return -1;
      };
  }
  
  //
  // Object
  //
  if (!Object.keys) {
      Object.keys = function (object) {
          var keys = [];
          for (var name in object) {
              if (Object.prototype.hasOwnProperty.call(object, name)) {
                  keys.push(name);
              }
          }
          return keys;
      };
  }
  
  //
  // String
  //
  if (!String.prototype.trim) {
      String.prototype.trim = function () {
          return String(this).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
      };
  }
  var less, tree, charset;
  
  if (typeof environment === "object" && ({}).toString.call(environment) === "[object Environment]") {
      // Rhino
      // Details on how to detect Rhino: https://github.com/ringo/ringojs/issues/88
      if (typeof(window) === 'undefined') { less = {} }
      else                                { less = window.less = {} }
      tree = less.tree = {};
      less.mode = 'rhino';
  } else if (typeof(window) === 'undefined') {
      // Node.js
      less = exports,
      tree = require('./tree');
      less.mode = 'node';
  } else {
      // Browser
      if (typeof(window.less) === 'undefined') { window.less = {} }
      less = window.less,
      tree = window.less.tree = {};
      less.mode = 'browser';
  }
  //
  // less.js - parser
  //
  //    A relatively straight-forward predictive parser.
  //    There is no tokenization/lexing stage, the input is parsed
  //    in one sweep.
  //
  //    To make the parser fast enough to run in the browser, several
  //    optimization had to be made:
  //
  //    - Matching and slicing on a huge input is often cause of slowdowns.
  //      The solution is to chunkify the input into smaller strings.
  //      The chunks are stored in the `chunks` var,
  //      `j` holds the current chunk index, and `current` holds
  //      the index of the current chunk in relation to `input`.
  //      This gives us an almost 4x speed-up.
  //
  //    - In many cases, we don't need to match individual tokens;
  //      for example, if a value doesn't hold any variables, operations
  //      or dynamic references, the parser can effectively 'skip' it,
  //      treating it as a literal.
  //      An example would be '1px solid #000' - which evaluates to itself,
  //      we don't need to know what the individual components are.
  //      The drawback, of course is that you don't get the benefits of
  //      syntax-checking on the CSS. This gives us a 50% speed-up in the parser,
  //      and a smaller speed-up in the code-gen.
  //
  //
  //    Token matching is done with the `$` function, which either takes
  //    a terminal string or regexp, or a non-terminal function to call.
  //    It also takes care of moving all the indices forwards.
  //
  //
  less.Parser = function Parser(env) {
      var input,       // LeSS input string
          i,           // current index in `input`
          j,           // current chunk
          temp,        // temporarily holds a chunk's state, for backtracking
          memo,        // temporarily holds `i`, when backtracking
          furthest,    // furthest index the parser has gone to
          chunks,      // chunkified input
          current,     // index of current chunk, in `input`
          parser;
  
      var that = this;
  
      // Top parser on an import tree must be sure there is one "env"
      // which will then be passed arround by reference.
      var env = env || { };
      // env.contents and files must be passed arround with top env
      if (!env.contents) { env.contents = {}; }
      env.rootpath = env.rootpath || '';       // env.rootpath must be initialized to '' if not provided
      if (!env.files) { env.files = {}; }
  
      // This function is called after all files
      // have been imported through `@import`.
      var finish = function () {};
  
      var imports = this.imports = {
          paths: env.paths || [],  // Search paths, when importing
          queue: [],               // Files which haven't been imported yet
          files: env.files,        // Holds the imported parse trees
          contents: env.contents,  // Holds the imported file contents
          mime:  env.mime,         // MIME type of .less files
          error: null,             // Error in parsing/evaluating an import
          push: function (path, callback) {
              var that = this;
              this.queue.push(path);
  
              //
              // Import a file asynchronously
              //
              less.Parser.importer(path, this.paths, function (e, root, fullPath) {
                  that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue
  
                  var imported = fullPath in that.files;
  
                  that.files[fullPath] = root;                        // Store the root
  
                  if (e && !that.error) { that.error = e }
  
                  callback(e, root, imported);
  
                  if (that.queue.length === 0) { finish(that.error) }       // Call `finish` if we're done importing
              }, env);
          }
      };
  
      function save()    { temp = chunks[j], memo = i, current = i }
      function restore() { chunks[j] = temp, i = memo, current = i }
  
      function sync() {
          if (i > current) {
              chunks[j] = chunks[j].slice(i - current);
              current = i;
          }
      }
      function isWhitespace(c) {
          // Could change to \s?
          var code = c.charCodeAt(0);
          return code === 32 || code === 10 || code === 9;
      }
      //
      // Parse from a token, regexp or string, and move forward if match
      //
      function $(tok) {
          var match, args, length, index, k;
  
          //
          // Non-terminal
          //
          if (tok instanceof Function) {
              return tok.call(parser.parsers);
          //
          // Terminal
          //
          //     Either match a single character in the input,
          //     or match a regexp in the current chunk (chunk[j]).
          //
          } else if (typeof(tok) === 'string') {
              match = input.charAt(i) === tok ? tok : null;
              length = 1;
              sync ();
          } else {
              sync ();
  
              if (match = tok.exec(chunks[j])) {
                  length = match[0].length;
              } else {
                  return null;
              }
          }
  
          // The match is confirmed, add the match length to `i`,
          // and consume any extra white-space characters (' ' || '\n')
          // which come after that. The reason for this is that LeSS's
          // grammar is mostly white-space insensitive.
          //
          if (match) {
              skipWhitespace(length);
  
              if(typeof(match) === 'string') {
                  return match;
              } else {
                  return match.length === 1 ? match[0] : match;
              }
          }
      }
  
      function skipWhitespace(length) {
          var oldi = i, oldj = j,
              endIndex = i + chunks[j].length,
              mem = i += length;
  
          while (i < endIndex) {
              if (! isWhitespace(input.charAt(i))) { break }
              i++;
          }
          chunks[j] = chunks[j].slice(length + (i - mem));
          current = i;
  
          if (chunks[j].length === 0 && j < chunks.length - 1) { j++ }
  
          return oldi !== i || oldj !== j;
      }
  
      function expect(arg, msg) {
          var result = $(arg);
          if (! result) {
              error(msg || (typeof(arg) === 'string' ? "expected '" + arg + "' got '" + input.charAt(i) + "'"
                                                     : "unexpected token"));
          } else {
              return result;
          }
      }
  
      function error(msg, type) {
          var e = new Error(msg);
          e.index = i;
          e.type = type || 'Syntax';
          throw e;
      }
  
      // Same as $(), but don't change the state of the parser,
      // just return the match.
      function peek(tok) {
          if (typeof(tok) === 'string') {
              return input.charAt(i) === tok;
          } else {
              if (tok.test(chunks[j])) {
                  return true;
              } else {
                  return false;
              }
          }
      }
  
      function getInput(e, env) {
          if (e.filename && env.filename && (e.filename !== env.filename)) {
              return parser.imports.contents[e.filename];
          } else {
              return input;
          }
      }
  
      function getLocation(index, input) {
          for (var n = index, column = -1;
                   n >= 0 && input.charAt(n) !== '\n';
                   n--) { column++ }
  
          return { line:   typeof(index) === 'number' ? (input.slice(0, index).match(/\n/g) || "").length : null,
                   column: column };
      }
  
      function getFileName(e) {
          if(less.mode === 'browser' || less.mode === 'rhino')
              return e.filename;
          else
              return require('path').resolve(e.filename);
      }
  
      function getDebugInfo(index, inputStream, e) {
          return {
              lineNumber: getLocation(index, inputStream).line + 1,
              fileName: getFileName(e)
          };
      }
  
      function LessError(e, env) {
          var input = getInput(e, env),
              loc = getLocation(e.index, input),
              line = loc.line,
              col  = loc.column,
              lines = input.split('\n');
  
          this.type = e.type || 'Syntax';
          this.message = e.message;
          this.filename = e.filename || env.filename;
          this.index = e.index;
          this.line = typeof(line) === 'number' ? line + 1 : null;
          this.callLine = e.call && (getLocation(e.call, input).line + 1);
          this.callExtract = lines[getLocation(e.call, input).line];
          this.stack = e.stack;
          this.column = col;
          this.extract = [
              lines[line - 1],
              lines[line],
              lines[line + 1]
          ];
      }
  
      this.env = env = env || {};
  
      // The optimization level dictates the thoroughness of the parser,
      // the lower the number, the less nodes it will create in the tree.
      // This could matter for debugging, or if you want to access
      // the individual nodes in the tree.
      this.optimization = ('optimization' in this.env) ? this.env.optimization : 1;
  
      this.env.filename = this.env.filename || null;
  
      //
      // The Parser
      //
      return parser = {
  
          imports: imports,
          //
          // Parse an input string into an abstract syntax tree,
          // call `callback` when done.
          //
          parse: function (str, callback) {
              var root, start, end, zone, line, lines, buff = [], c, error = null;
  
              i = j = current = furthest = 0;
              input = str.replace(/\r\n/g, '\n');
  
              // Remove potential UTF Byte Order Mark
              input = input.replace(/^\uFEFF/, '');
  
              // Split the input into chunks.
              chunks = (function (chunks) {
                  var j = 0,
                      skip = /(?:@\{[\w-]+\}|[^"'`\{\}\/\(\)\\])+/g,
                      comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,
                      string = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`]|\\.)*)`/g,
                      level = 0,
                      match,
                      chunk = chunks[0],
                      inParam;
  
                  for (var i = 0, c, cc; i < input.length;) {
                      skip.lastIndex = i;
                      if (match = skip.exec(input)) {
                          if (match.index === i) {
                              i += match[0].length;
                              chunk.push(match[0]);
                          }
                      }
                      c = input.charAt(i);
                      comment.lastIndex = string.lastIndex = i;
  
                      if (match = string.exec(input)) {
                          if (match.index === i) {
                              i += match[0].length;
                              chunk.push(match[0]);
                              continue;
                          }
                      }
  
                      if (!inParam && c === '/') {
                          cc = input.charAt(i + 1);
                          if (cc === '/' || cc === '*') {
                              if (match = comment.exec(input)) {
                                  if (match.index === i) {
                                      i += match[0].length;
                                      chunk.push(match[0]);
                                      continue;
                                  }
                              }
                          }
                      }
                      
                      switch (c) {
                          case '{': if (! inParam) { level ++;        chunk.push(c);                           break }
                          case '}': if (! inParam) { level --;        chunk.push(c); chunks[++j] = chunk = []; break }
                          case '(': if (! inParam) { inParam = true;  chunk.push(c);                           break }
                          case ')': if (  inParam) { inParam = false; chunk.push(c);                           break }
                          default:                                    chunk.push(c);
                      }
                      
                      i++;
                  }
                  if (level != 0) {
                      error = new(LessError)({
                          index: i-1,
                          type: 'Parse',
                          message: (level > 0) ? "missing closing `}`" : "missing opening `{`",
                          filename: env.filename
                      }, env);
                  }
  
                  return chunks.map(function (c) { return c.join('') });;
              })([[]]);
  
              if (error) {
                  return callback(error, env);
              }
  
              // Start with the primary rule.
              // The whole syntax tree is held under a Ruleset node,
              // with the `root` property set to true, so no `{}` are
              // output. The callback is called when the input is parsed.
              try {
                  root = new(tree.Ruleset)([], $(this.parsers.primary));
                  root.root = true;
              } catch (e) {
                  return callback(new(LessError)(e, env));
              }
  
              root.toCSS = (function (evaluate) {
                  var line, lines, column;
  
                  return function (options, variables) {
                      var frames = [], importError;
  
                      options = options || {};
                      //
                      // Allows setting variables with a hash, so:
                      //
                      //   `{ color: new(tree.Color)('#f01') }` will become:
                      //
                      //   new(tree.Rule)('@color',
                      //     new(tree.Value)([
                      //       new(tree.Expression)([
                      //         new(tree.Color)('#f01')
                      //       ])
                      //     ])
                      //   )
                      //
                      if (typeof(variables) === 'object' && !Array.isArray(variables)) {
                          variables = Object.keys(variables).map(function (k) {
                              var value = variables[k];
  
                              if (! (value instanceof tree.Value)) {
                                  if (! (value instanceof tree.Expression)) {
                                      value = new(tree.Expression)([value]);
                                  }
                                  value = new(tree.Value)([value]);
                              }
                              return new(tree.Rule)('@' + k, value, false, 0);
                          });
                          frames = [new(tree.Ruleset)(null, variables)];
                      }
  
                      try {
                          var css = evaluate.call(this, { frames: frames })
                                            .toCSS([], { compress: options.compress || false, dumpLineNumbers: env.dumpLineNumbers });
                      } catch (e) {
                          throw new(LessError)(e, env);
                      }
  
                      if ((importError = parser.imports.error)) { // Check if there was an error during importing
                          if (importError instanceof LessError) throw importError;
                          else                                  throw new(LessError)(importError, env);
                      }
  
                      if (options.yuicompress && less.mode === 'node') {
                          return require('ycssmin').cssmin(css);
                      } else if (options.compress) {
                          return css.replace(/(\s)+/g, "$1");
                      } else {
                          return css;
                      }
                  };
              })(root.eval);
  
              // If `i` is smaller than the `input.length - 1`,
              // it means the parser wasn't able to parse the whole
              // string, so we've got a parsing error.
              //
              // We try to extract a \n delimited string,
              // showing the line where the parse error occured.
              // We split it up into two parts (the part which parsed,
              // and the part which didn't), so we can color them differently.
              if (i < input.length - 1) {
                  i = furthest;
                  lines = input.split('\n');
                  line = (input.slice(0, i).match(/\n/g) || "").length + 1;
  
                  for (var n = i, column = -1; n >= 0 && input.charAt(n) !== '\n'; n--) { column++ }
  
                  error = {
                      type: "Parse",
                      message: "Syntax Error on line " + line,
                      index: i,
                      filename: env.filename,
                      line: line,
                      column: column,
                      extract: [
                          lines[line - 2],
                          lines[line - 1],
                          lines[line]
                      ]
                  };
              }
  
              if (this.imports.queue.length > 0) {
                  finish = function (e) {
                      e = error || e;
                      if (e) callback(e);
                      else callback(null, root);
                  };
              } else {
                  callback(error, root);
              }
          },
  
          //
          // Here in, the parsing rules/functions
          //
          // The basic structure of the syntax tree generated is as follows:
          //
          //   Ruleset ->  Rule -> Value -> Expression -> Entity
          //
          // Here's some LESS code:
          //
          //    .class {
          //      color: #fff;
          //      border: 1px solid #000;
          //      width: @w + 4px;
          //      > .child {...}
          //    }
          //
          // And here's what the parse tree might look like:
          //
          //     Ruleset (Selector '.class', [
          //         Rule ("color",  Value ([Expression [Color #fff]]))
          //         Rule ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]]))
          //         Rule ("width",  Value ([Expression [Operation "+" [Variable "@w"][Dimension 4px]]]))
          //         Ruleset (Selector [Element '>', '.child'], [...])
          //     ])
          //
          //  In general, most rules will try to parse a token with the `$()` function, and if the return
          //  value is truly, will return a new node, of the relevant type. Sometimes, we need to check
          //  first, before parsing, that's when we use `peek()`.
          //
          parsers: {
              //
              // The `primary` rule is the *entry* and *exit* point of the parser.
              // The rules here can appear at any level of the parse tree.
              //
              // The recursive nature of the grammar is an interplay between the `block`
              // rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,
              // as represented by this simplified grammar:
              //
              //     primary  →  (ruleset | rule)+
              //     ruleset  →  selector+ block
              //     block    →  '{' primary '}'
              //
              // Only at one point is the primary rule not called from the
              // block rule: at the root level.
              //
              primary: function () {
                  var node, root = [];
  
                  while ((node = $(this.mixin.definition) || $(this.rule)    ||  $(this.ruleset) ||
                                 $(this.mixin.call)       || $(this.comment) ||  $(this.directive))
                                 || $(/^[\s\n]+/) || $(/^;+/)) {
                      node && root.push(node);
                  }
                  return root;
              },
  
              // We create a Comment node for CSS comments `/* */`,
              // but keep the LeSS comments `//` silent, by just skipping
              // over them.
              comment: function () {
                  var comment;
  
                  if (input.charAt(i) !== '/') return;
  
                  if (input.charAt(i + 1) === '/') {
                      return new(tree.Comment)($(/^\/\/.*/), true);
                  } else if (comment = $(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) {
                      return new(tree.Comment)(comment);
                  }
              },
  
              //
              // Entities are tokens which can be found inside an Expression
              //
              entities: {
                  //
                  // A string, which supports escaping " and '
                  //
                  //     "milky way" 'he\'s the one!'
                  //
                  quoted: function () {
                      var str, j = i, e;
  
                      if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
                      if (input.charAt(j) !== '"' && input.charAt(j) !== "'") return;
  
                      e && $('~');
  
                      if (str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) {
                          return new(tree.Quoted)(str[0], str[1] || str[2], e);
                      }
                  },
  
                  //
                  // A catch-all word, such as:
                  //
                  //     black border-collapse
                  //
                  keyword: function () {
                      var k;
  
                      if (k = $(/^[_A-Za-z-][_A-Za-z0-9-]*/)) {
                          if (tree.colors.hasOwnProperty(k)) {
                              // detect named color
                              return new(tree.Color)(tree.colors[k].slice(1));
                          } else {
                              return new(tree.Keyword)(k);
                          }
                      }
                  },
  
                  //
                  // A function call
                  //
                  //     rgb(255, 0, 255)
                  //
                  // We also try to catch IE's `alpha()`, but let the `alpha` parser
                  // deal with the details.
                  //
                  // The arguments are parsed with the `entities.arguments` parser.
                  //
                  call: function () {
                      var name, nameLC, args, alpha_ret, index = i;
  
                      if (! (name = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(chunks[j]))) return;
  
                      name = name[1];
                      nameLC = name.toLowerCase();
  
                      if (nameLC === 'url') { return null }
                      else                { i += name.length }
  
                      if (nameLC === 'alpha') {
                          alpha_ret = $(this.alpha);
                          if(typeof alpha_ret !== 'undefined') {
                              return alpha_ret;
                          }
                      }
  
                      $('('); // Parse the '(' and consume whitespace.
  
                      args = $(this.entities.arguments);
  
                      if (! $(')')) return;
  
                      if (name) { return new(tree.Call)(name, args, index, env.filename) }
                  },
                  arguments: function () {
                      var args = [], arg;
  
                      while (arg = $(this.entities.assignment) || $(this.expression)) {
                          args.push(arg);
                          if (! $(',')) { break }
                      }
                      return args;
                  },
                  literal: function () {
                      return $(this.entities.ratio) ||
                             $(this.entities.dimension) ||
                             $(this.entities.color) ||
                             $(this.entities.quoted) ||
                             $(this.entities.unicodeDescriptor);
                  },
  
                  // Assignments are argument entities for calls.
                  // They are present in ie filter properties as shown below.
                  //
                  //     filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* )
                  //
  
                  assignment: function () {
                      var key, value;
                      if ((key = $(/^\w+(?=\s?=)/i)) && $('=') && (value = $(this.entity))) {
                          return new(tree.Assignment)(key, value);
                      }
                  },
  
                  //
                  // Parse url() tokens
                  //
                  // We use a specific rule for urls, because they don't really behave like
                  // standard function calls. The difference is that the argument doesn't have
                  // to be enclosed within a string, so it can't be parsed as an Expression.
                  //
                  url: function () {
                      var value;
  
                      if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
                      value = $(this.entities.quoted)  || $(this.entities.variable) ||
                              $(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || "";
  
                      expect(')');
  
                      return new(tree.URL)((value.value != null || value instanceof tree.Variable)
                                          ? value : new(tree.Anonymous)(value), env.rootpath);
                  },
  
                  //
                  // A Variable entity, such as `@fink`, in
                  //
                  //     width: @fink + 2px
                  //
                  // We use a different parser for variable definitions,
                  // see `parsers.variable`.
                  //
                  variable: function () {
                      var name, index = i;
  
                      if (input.charAt(i) === '@' && (name = $(/^@@?[\w-]+/))) {
                          return new(tree.Variable)(name, index, env.filename);
                      }
                  },
  
                  // A variable entity useing the protective {} e.g. @{var}
                  variableCurly: function () {
                      var name, curly, index = i;
  
                      if (input.charAt(i) === '@' && (curly = $(/^@\{([\w-]+)\}/))) {
                          return new(tree.Variable)("@" + curly[1], index, env.filename);
                      }
                  },
  
                  //
                  // A Hexadecimal color
                  //
                  //     #4F3C2F
                  //
                  // `rgb` and `hsl` colors are parsed through the `entities.call` parser.
                  //
                  color: function () {
                      var rgb;
  
                      if (input.charAt(i) === '#' && (rgb = $(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/))) {
                          return new(tree.Color)(rgb[1]);
                      }
                  },
  
                  //
                  // A Dimension, that is, a number and a unit
                  //
                  //     0.5em 95%
                  //
                  dimension: function () {
                      var value, c = input.charCodeAt(i);
                      //Is the first char of the dimension 0-9, '.', '+' or '-'
                      if ((c > 57 || c < 43) || c === 47 || c == 44) return;
  
                      if (value = $(/^([+-]?\d*\.?\d+)(px|%|em|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn|dpi|dpcm|dppx|rem|vw|vh|vmin|vm|ch)?/)) {
                          return new(tree.Dimension)(value[1], value[2]);
                      }
                  },
  
                  //
                  // A Ratio
                  //
                  //    16/9
                  //
                  ratio: function () {
                    var value, c = input.charCodeAt(i);
                    if (c > 57 || c < 48) return;
  
                    if (value = $(/^(\d+\/\d+)/)) {
                      return new(tree.Ratio)(value[1]);
                    }
                  },
                  
                  //
                  // A unicode descriptor, as is used in unicode-range
                  //
                  // U+0??  or U+00A1-00A9
                  //
                  unicodeDescriptor: function () {
                      var ud;
                      
                      if (ud = $(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/)) {
                          return new(tree.UnicodeDescriptor)(ud[0]);
                      }
                  },
  
                  //
                  // JavaScript code to be evaluated
                  //
                  //     `window.location.href`
                  //
                  javascript: function () {
                      var str, j = i, e;
  
                      if (input.charAt(j) === '~') { j++, e = true } // Escaped strings
                      if (input.charAt(j) !== '`') { return }
  
                      e && $('~');
  
                      if (str = $(/^`([^`]*)`/)) {
                          return new(tree.JavaScript)(str[1], i, e);
                      }
                  }
              },
  
              //
              // The variable part of a variable definition. Used in the `rule` parser
              //
              //     @fink:
              //
              variable: function () {
                  var name;
  
                  if (input.charAt(i) === '@' && (name = $(/^(@[\w-]+)\s*:/))) { return name[1] }
              },
  
              //
              // A font size/line-height shorthand
              //
              //     small/12px
              //
              // We need to peek first, or we'll match on keywords and dimensions
              //
              shorthand: function () {
                  var a, b;
  
                  if (! peek(/^[@\w.%-]+\/[@\w.-]+/)) return;
  
                  save();
  
                  if ((a = $(this.entity)) && $('/') && (b = $(this.entity))) {
                      return new(tree.Shorthand)(a, b);
                  }
  
                  restore();
              },
  
              //
              // Mixins
              //
              mixin: {
                  //
                  // A Mixin call, with an optional argument list
                  //
                  //     #mixins > .square(#fff);
                  //     .rounded(4px, black);
                  //     .button;
                  //
                  // The `while` loop is there because mixins can be
                  // namespaced, but we only support the child and descendant
                  // selector for now.
                  //
                  call: function () {
                      var elements = [], e, c, argsSemiColon = [], argsComma = [], args, delim, arg, nameLoop, expressions, isSemiColonSeperated, expressionContainsNamed, index = i, s = input.charAt(i), name, value, important = false;
  
                      if (s !== '.' && s !== '#') { return }
                      
                      save(); // stop us absorbing part of an invalid selector
  
                      while (e = $(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/)) {
                          elements.push(new(tree.Element)(c, e, i));
                          c = $('>');
                      }
                      if ($('(')) {
                          expressions = [];
                          while (arg = $(this.expression)) {
                              nameLoop = null;
                              value = arg;
  
                              // Variable
                              if (arg.value.length == 1) {
                                  var val = arg.value[0];
                                  if (val instanceof tree.Variable) {
                                      if ($(':')) {
                                          if (expressions.length > 0) {
                                              if (isSemiColonSeperated) {
                                                  error("Cannot mix ; and , as delimiter types");
                                              }
                                              expressionContainsNamed = true;
                                          }
                                          value = expect(this.expression);
                                          nameLoop = (name = val.name);
                                      }
                                  }
                              }
                              
                              expressions.push(value);
                              
                              argsComma.push({ name: nameLoop, value: value });
                              
                              if ($(',')) {
                                  continue;
                              }
                              
                              if ($(';') || isSemiColonSeperated) {
                              
                                  if (expressionContainsNamed) {
                                      error("Cannot mix ; and , as delimiter types");
                                  }
                              
                                  isSemiColonSeperated = true;
                                                          
                                  if (expressions.length > 1) {
                                      value = new(tree.Value)(expressions);
                                  }
                                  argsSemiColon.push({ name: name, value: value });
                              
                                  name = null;
                                  expressions = [];
                                  expressionContainsNamed = false;
                              }
                          }
  
                          expect(')');
                      }
  
                      args = isSemiColonSeperated ? argsSemiColon : argsComma;
  
                      if ($(this.important)) {
                          important = true;
                      }
  
                      if (elements.length > 0 && ($(';') || peek('}'))) {
                          return new(tree.mixin.Call)(elements, args, index, env.filename, important);
                      }
                      
                      restore();
                  },
  
                  //
                  // A Mixin definition, with a list of parameters
                  //
                  //     .rounded (@radius: 2px, @color) {
                  //        ...
                  //     }
                  //
                  // Until we have a finer grained state-machine, we have to
                  // do a look-ahead, to make sure we don't have a mixin call.
                  // See the `rule` function for more information.
                  //
                  // We start by matching `.rounded (`, and then proceed on to
                  // the argument list, which has optional default values.
                  // We store the parameters in `params`, with a `value` key,
                  // if there is a value, such as in the case of `@radius`.
                  //
                  // Once we've got our params list, and a closing `)`, we parse
                  // the `{...}` block.
                  //
                  definition: function () {
                      var name, params = [], match, ruleset, param, value, cond, variadic = false;
                      if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') ||
                          peek(/^[^{]*\}/)) return;
  
                      save();
  
                      if (match = $(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/)) {
                          name = match[1];
  
                          do {
                              $(this.comment);
                              if (input.charAt(i) === '.' && $(/^\.{3}/)) {
                                  variadic = true;
                                  params.push({ variadic: true });
                                  break;
                              } else if (param = $(this.entities.variable) || $(this.entities.literal)
                                                                           || $(this.entities.keyword)) {
                                  // Variable
                                  if (param instanceof tree.Variable) {
                                      if ($(':')) {
                                          value = expect(this.expression, 'expected expression');
                                          params.push({ name: param.name, value: value });
                                      } else if ($(/^\.{3}/)) {
                                          params.push({ name: param.name, variadic: true });
                                          variadic = true;
                                          break;
                                      } else {
                                          params.push({ name: param.name });
                                      }
                                  } else {
                                      params.push({ value: param });
                                  }
                              } else {
                                  break;
                              }
                          } while ($(',') || $(';'))
  
                          // .mixincall("@{a}"); 
                          // looks a bit like a mixin definition.. so we have to be nice and restore
                          if (!$(')')) {
                              furthest = i;
                              restore();
                          }
                          
                          $(this.comment);
  
                          if ($(/^when/)) { // Guard
                              cond = expect(this.conditions, 'expected condition');
                          }
  
                          ruleset = $(this.block);
  
                          if (ruleset) {
                              return new(tree.mixin.Definition)(name, params, ruleset, cond, variadic);
                          } else {
                              restore();
                          }
                      }
                  }
              },
  
              //
              // Entities are the smallest recognized token,
              // and can be found inside a rule's value.
              //
              entity: function () {
                  return $(this.entities.literal) || $(this.entities.variable) || $(this.entities.url) ||
                         $(this.entities.call)    || $(this.entities.keyword)  ||$(this.entities.javascript) ||
                         $(this.comment);
              },
  
              //
              // A Rule terminator. Note that we use `peek()` to check for '}',
              // because the `block` rule will be expecting it, but we still need to make sure
              // it's there, if ';' was ommitted.
              //
              end: function () {
                  return $(';') || peek('}');
              },
  
              //
              // IE's alpha function
              //
              //     alpha(opacity=88)
              //
              alpha: function () {
                  var value;
  
                  if (! $(/^\(opacity=/i)) return;
                  if (value = $(/^\d+/) || $(this.entities.variable)) {
                      expect(')');
                      return new(tree.Alpha)(value);
                  }
              },
  
              //
              // A Selector Element
              //
              //     div
              //     + h1
              //     #socks
              //     input[type="text"]
              //
              // Elements are the building blocks for Selectors,
              // they are made out of a `Combinator` (see combinator rule),
              // and an element name, such as a tag a class, or `*`.
              //
              element: function () {
                  var e, t, c, v;
  
                  c = $(this.combinator);
  
                  e = $(/^(?:\d+\.\d+|\d+)%/) || $(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) ||
                      $('*') || $('&') || $(this.attribute) || $(/^\([^()@]+\)/) || $(/^[\.#](?=@)/) || $(this.entities.variableCurly);
  
                  if (! e) {
                      if ($('(')) {
                          if ((v = ($(this.entities.variableCurly) || 
                                  $(this.entities.variable) || 
                                  $(this.selector))) && 
                                  $(')')) {
                              e = new(tree.Paren)(v);
                          }
                      }
                  }
  
                  if (e) { return new(tree.Element)(c, e, i) }
              },
  
              //
              // Combinators combine elements together, in a Selector.
              //
              // Because our parser isn't white-space sensitive, special care
              // has to be taken, when parsing the descendant combinator, ` `,
              // as it's an empty space. We have to check the previous character
              // in the input, to see if it's a ` ` character. More info on how
              // we deal with this in *combinator.js*.
              //
              combinator: function () {
                  var match, c = input.charAt(i);
  
                  if (c === '>' || c === '+' || c === '~' || c === '|') {
                      i++;
                      while (input.charAt(i).match(/\s/)) { i++ }
                      return new(tree.Combinator)(c);
                  } else if (input.charAt(i - 1).match(/\s/)) {
                      return new(tree.Combinator)(" ");
                  } else {
                      return new(tree.Combinator)(null);
                  }
              },
  
              //
              // A CSS Selector
              //
              //     .class > div + h1
              //     li a:hover
              //
              // Selectors are made out of one or more Elements, see above.
              //
              selector: function () {
                  var sel, e, elements = [], c, match;
  
                  // depreciated, will be removed soon
                  if ($('(')) {
                      sel = $(this.entity);
                      if (!$(')')) { return null; }
                      return new(tree.Selector)([new(tree.Element)('', sel, i)]);
                  }
  
                  while (e = $(this.element)) {
                      c = input.charAt(i);
                      elements.push(e)
                      if (c === '{' || c === '}' || c === ';' || c === ',' || c === ')') { break }
                  }
  
                  if (elements.length > 0) { return new(tree.Selector)(elements) }
              },
              attribute: function () {
                  var attr = '', key, val, op;
  
                  if (! $('[')) return;
  
                  if (key = $(/^(?:[_A-Za-z0-9-]|\\.)+/) || $(this.entities.quoted)) {
                      if ((op = $(/^[|~*$^]?=/)) &&
                          (val = $(this.entities.quoted) || $(/^[\w-]+/))) {
                          attr = [key, op, val.toCSS ? val.toCSS() : val].join('');
                      } else { attr = key }
                  }
  
                  if (! $(']')) return;
  
                  if (attr) { return "[" + attr + "]" }
              },
  
              //
              // The `block` rule is used by `ruleset` and `mixin.definition`.
              // It's a wrapper around the `primary` rule, with added `{}`.
              //
              block: function () {
                  var content;
                  if ($('{') && (content = $(this.primary)) && $('}')) {
                      return content;
                  }
              },
  
              //
              // div, .class, body > p {...}
              //
              ruleset: function () {
                  var selectors = [], s, rules, match, debugInfo;
                  
                  save();
  
                  if (env.dumpLineNumbers)
                      debugInfo = getDebugInfo(i, input, env);
  
                  while (s = $(this.selector)) {
                      selectors.push(s);
                      $(this.comment);
                      if (! $(',')) { break }
                      $(this.comment);
                  }
  
                  if (selectors.length > 0 && (rules = $(this.block))) {
                      var ruleset = new(tree.Ruleset)(selectors, rules, env.strictImports);
                      if (env.dumpLineNumbers)
                          ruleset.debugInfo = debugInfo;
                      return ruleset;
                  } else {
                      // Backtrack
                      furthest = i;
                      restore();
                  }
              },
              rule: function () {
                  var name, value, c = input.charAt(i), important, match;
                  save();
  
                  if (c === '.' || c === '#' || c === '&') { return }
  
                  if (name = $(this.variable) || $(this.property)) {
                      if ((name.charAt(0) != '@') && (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j]))) {
                          i += match[0].length - 1;
                          value = new(tree.Anonymous)(match[1]);
                      } else if (name === "font") {
                          value = $(this.font);
                      } else {
                          value = $(this.value);
                      }
                      important = $(this.important);
  
                      if (value && $(this.end)) {
                          return new(tree.Rule)(name, value, important, memo);
                      } else {
                          furthest = i;
                          restore();
                      }
                  }
              },
  
              //
              // An @import directive
              //
              //     @import "lib";
              //
              // Depending on our environemnt, importing is done differently:
              // In the browser, it's an XHR request, in Node, it would be a
              // file-system operation. The function used for importing is
              // stored in `import`, which we pass to the Import constructor.
              //
              "import": function () {
                  var path, features, index = i;
                  
                  save();
                  
                  var dir = $(/^@import(?:-(once))?\s+/);
  
                  if (dir && (path = $(this.entities.quoted) || $(this.entities.url))) {
                      features = $(this.mediaFeatures);
                      if ($(';')) {
                          return new(tree.Import)(path, imports, features, (dir[1] === 'once'), index, env.rootpath);
                      }
                  }
                  
                  restore();
              },
  
              mediaFeature: function () {
                  var e, p, nodes = [];
  
                  do {
                      if (e = $(this.entities.keyword)) {
                          nodes.push(e);
                      } else if ($('(')) {
                          p = $(this.property);
                          e = $(this.entity);
                          if ($(')')) {
                              if (p && e) {
                                  nodes.push(new(tree.Paren)(new(tree.Rule)(p, e, null, i, true)));
                              } else if (e) {
                                  nodes.push(new(tree.Paren)(e));
                              } else {
                                  return null;
                              }
                          } else { return null }
                      }
                  } while (e);
  
                  if (nodes.length > 0) {
                      return new(tree.Expression)(nodes);
                  }
              },
  
              mediaFeatures: function () {
                  var e, features = [];
  
                  do {
                    if (e = $(this.mediaFeature)) {
                        features.push(e);
                        if (! $(',')) { break }
                    } else if (e = $(this.entities.variable)) {
                        features.push(e);
                        if (! $(',')) { break }
                    }
                  } while (e);
  
                  return features.length > 0 ? features : null;
              },
  
              media: function () {
                  var features, rules, media, debugInfo;
  
                  if (env.dumpLineNumbers)
                      debugInfo = getDebugInfo(i, input, env);
  
                  if ($(/^@media/)) {
                      features = $(this.mediaFeatures);
  
                      if (rules = $(this.block)) {
                          media = new(tree.Media)(rules, features);
                          if(env.dumpLineNumbers)
                              media.debugInfo = debugInfo;
                          return media;
                      }
                  }
              },
  
              //
              // A CSS Directive
              //
              //     @charset "utf-8";
              //
              directive: function () {
                  var name, value, rules, identifier, e, nodes, nonVendorSpecificName,
                      hasBlock, hasIdentifier, hasExpression;
  
                  if (input.charAt(i) !== '@') return;
  
                  if (value = $(this['import']) || $(this.media)) {
                      return value;
                  }
                  
                  save();
  
                  name = $(/^@[a-z-]+/);
                  
                  if (!name) return;
  
                  nonVendorSpecificName = name;
                  if (name.charAt(1) == '-' && name.indexOf('-', 2) > 0) {
                      nonVendorSpecificName = "@" + name.slice(name.indexOf('-', 2) + 1);
                  }
  
                  switch(nonVendorSpecificName) {
                      case "@font-face":
                          hasBlock = true;
                          break;
                      case "@viewport":
                      case "@top-left":
                      case "@top-left-corner":
                      case "@top-center":
                      case "@top-right":
                      case "@top-right-corner":
                      case "@bottom-left":
                      case "@bottom-left-corner":
                      case "@bottom-center":
                      case "@bottom-right":
                      case "@bottom-right-corner":
                      case "@left-top":
                      case "@left-middle":
                      case "@left-bottom":
                      case "@right-top":
                      case "@right-middle":
                      case "@right-bottom":
                          hasBlock = true;
                          break;
                      case "@page":
                      case "@document":
                      case "@supports":
                      case "@keyframes":
                          hasBlock = true;
                          hasIdentifier = true;
                          break;
                      case "@namespace":
                          hasExpression = true;
                          break;
                  }
  
                  if (hasIdentifier) {
                      name += " " + ($(/^[^{]+/) || '').trim();
                  }
  
                  if (hasBlock)
                  {
                      if (rules = $(this.block)) {
                          return new(tree.Directive)(name, rules);
                      }
                  } else {
                      if ((value = hasExpression ? $(this.expression) : $(this.entity)) && $(';')) {
                          var directive = new(tree.Directive)(name, value);
                          if (env.dumpLineNumbers) {
                              directive.debugInfo = getDebugInfo(i, input, env);
                          }
                          return directive;
                      }
                  }
                  
                  restore();
              },
              font: function () {
                  var value = [], expression = [], weight, shorthand, font, e;
  
                  while (e = $(this.shorthand) || $(this.entity)) {
                      expression.push(e);
                  }
                  value.push(new(tree.Expression)(expression));
  
                  if ($(',')) {
                      while (e = $(this.expression)) {
                          value.push(e);
                          if (! $(',')) { break }
                      }
                  }
                  return new(tree.Value)(value);
              },
  
              //
              // A Value is a comma-delimited list of Expressions
              //
              //     font-family: Baskerville, Georgia, serif;
              //
              // In a Rule, a Value represents everything after the `:`,
              // and before the `;`.
              //
              value: function () {
                  var e, expressions = [], important;
  
                  while (e = $(this.expression)) {
                      expressions.push(e);
                      if (! $(',')) { break }
                  }
  
                  if (expressions.length > 0) {
                      return new(tree.Value)(expressions);
                  }
              },
              important: function () {
                  if (input.charAt(i) === '!') {
                      return $(/^! *important/);
                  }
              },
              sub: function () {
                  var e;
  
                  if ($('(') && (e = $(this.expression)) && $(')')) {
                      return e;
                  }
              },
              multiplication: function () {
                  var m, a, op, operation;
                  if (m = $(this.operand)) {
                      while (!peek(/^\/[*\/]/) && (op = ($('/') || $('*'))) && (a = $(this.operand))) {
                          operation = new(tree.Operation)(op, [operation || m, a]);
                      }
                      return operation || m;
                  }
              },
              addition: function () {
                  var m, a, op, operation;
                  if (m = $(this.multiplication)) {
                      while ((op = $(/^[-+]\s+/) || (!isWhitespace(input.charAt(i - 1)) && ($('+') || $('-')))) &&
                             (a = $(this.multiplication))) {
                          operation = new(tree.Operation)(op, [operation || m, a]);
                      }
                      return operation || m;
                  }
              },
              conditions: function () {
                  var a, b, index = i, condition;
  
                  if (a = $(this.condition)) {
                      while ($(',') && (b = $(this.condition))) {
                          condition = new(tree.Condition)('or', condition || a, b, index);
                      }
                      return condition || a;
                  }
              },
              condition: function () {
                  var a, b, c, op, index = i, negate = false;
  
                  if ($(/^not/)) { negate = true }
                  expect('(');
                  if (a = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) {
                      if (op = $(/^(?:>=|=<|[<=>])/)) {
                          if (b = $(this.addition) || $(this.entities.keyword) || $(this.entities.quoted)) {
                              c = new(tree.Condition)(op, a, b, index, negate);
                          } else {
                              error('expected expression');
                          }
                      } else {
                          c = new(tree.Condition)('=', a, new(tree.Keyword)('true'), index, negate);
                      }
                      expect(')');
                      return $(/^and/) ? new(tree.Condition)('and', c, $(this.condition)) : c;
                  }
              },
  
              //
              // An operand is anything that can be part of an operation,
              // such as a Color, or a Variable
              //
              operand: function () {
                  var negate, p = input.charAt(i + 1);
  
                  if (input.charAt(i) === '-' && (p === '@' || p === '(')) { negate = $('-') }
                  var o = $(this.sub) || $(this.entities.dimension) ||
                          $(this.entities.color) || $(this.entities.variable) ||
                          $(this.entities.call);
                  return negate ? new(tree.Operation)('*', [new(tree.Dimension)(-1), o])
                                : o;
              },
  
              //
              // Expressions either represent mathematical operations,
              // or white-space delimited Entities.
              //
              //     1px solid black
              //     @var * 2
              //
              expression: function () {
                  var e, delim, entities = [], d;
  
                  while (e = $(this.addition) || $(this.entity)) {
                      entities.push(e);
                  }
                  if (entities.length > 0) {
                      return new(tree.Expression)(entities);
                  }
              },
              property: function () {
                  var name;
  
                  if (name = $(/^(\*?-?[_a-z0-9-]+)\s*:/)) {
                      return name[1];
                  }
              }
          }
      };
  };
  
  if (less.mode === 'browser' || less.mode === 'rhino') {
      //
      // Used by `@import` directives
      //
      less.Parser.importer = function (path, paths, callback, env) {
          if (!/^([a-z-]+:)?\//.test(path) && paths.length > 0) {
              path = paths[0] + path;
          }
          // We pass `true` as 3rd argument, to force the reload of the import.
          // This is so we can get the syntax tree as opposed to just the CSS output,
          // as we need this to evaluate the current stylesheet.
          loadStyleSheet({ 
              href: path, 
              title: path, 
              type: env.mime, 
              contents: env.contents, 
              files: env.files, 
              rootpath: env.rootpath,
              entryPath: env.entryPath,
              relativeUrls: env.relativeUrls }, 
          function (e, root, data, sheet, _, path) {
              if (e && typeof(env.errback) === "function") {
                  env.errback.call(null, path, paths, callback, env);
              } else {
                  callback.call(null, e, root, path);
              }
          }, true);
      };
  }
  
  (function (tree) {
  
  tree.functions = {
      rgb: function (r, g, b) {
          return this.rgba(r, g, b, 1.0);
      },
      rgba: function (r, g, b, a) {
          var rgb = [r, g, b].map(function (c) { return scaled(c, 256); });
          a = number(a);
          return new(tree.Color)(rgb, a);
      },
      hsl: function (h, s, l) {
          return this.hsla(h, s, l, 1.0);
      },
      hsla: function (h, s, l, a) {
          h = (number(h) % 360) / 360;
          s = number(s); l = number(l); a = number(a);
  
          var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
          var m1 = l * 2 - m2;
  
          return this.rgba(hue(h + 1/3) * 255,
                           hue(h)       * 255,
                           hue(h - 1/3) * 255,
                           a);
  
          function hue(h) {
              h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
              if      (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
              else if (h * 2 < 1) return m2;
              else if (h * 3 < 2) return m1 + (m2 - m1) * (2/3 - h) * 6;
              else                return m1;
          }
      },
  
      hsv: function(h, s, v) {
          return this.hsva(h, s, v, 1.0);
      },
  
      hsva: function(h, s, v, a) {
          h = ((number(h) % 360) / 360) * 360;
          s = number(s); v = number(v); a = number(a);
  
          var i, f;
          i = Math.floor((h / 60) % 6);
          f = (h / 60) - i;
  
          var vs = [v,
                    v * (1 - s),
                    v * (1 - f * s),
                    v * (1 - (1 - f) * s)];
          var perm = [[0, 3, 1],
                      [2, 0, 1],
                      [1, 0, 3],
                      [1, 2, 0],
                      [3, 1, 0],
                      [0, 1, 2]];
  
          return this.rgba(vs[perm[i][0]] * 255,
                           vs[perm[i][1]] * 255,
                           vs[perm[i][2]] * 255,
                           a);
      },
  
      hue: function (color) {
          return new(tree.Dimension)(Math.round(color.toHSL().h));
      },
      saturation: function (color) {
          return new(tree.Dimension)(Math.round(color.toHSL().s * 100), '%');
      },
      lightness: function (color) {
          return new(tree.Dimension)(Math.round(color.toHSL().l * 100), '%');
      },
      red: function (color) {
          return new(tree.Dimension)(color.rgb[0]);
      },
      green: function (color) {
          return new(tree.Dimension)(color.rgb[1]);
      },
      blue: function (color) {
          return new(tree.Dimension)(color.rgb[2]);
      },
      alpha: function (color) {
          return new(tree.Dimension)(color.toHSL().a);
      },
      luma: function (color) {
          return new(tree.Dimension)(Math.round((0.2126 * (color.rgb[0]/255) +
              0.7152 * (color.rgb[1]/255) +
              0.0722 * (color.rgb[2]/255)) *
              color.alpha * 100), '%');
      },
      saturate: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.s += amount.value / 100;
          hsl.s = clamp(hsl.s);
          return hsla(hsl);
      },
      desaturate: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.s -= amount.value / 100;
          hsl.s = clamp(hsl.s);
          return hsla(hsl);
      },
      lighten: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.l += amount.value / 100;
          hsl.l = clamp(hsl.l);
          return hsla(hsl);
      },
      darken: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.l -= amount.value / 100;
          hsl.l = clamp(hsl.l);
          return hsla(hsl);
      },
      fadein: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.a += amount.value / 100;
          hsl.a = clamp(hsl.a);
          return hsla(hsl);
      },
      fadeout: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.a -= amount.value / 100;
          hsl.a = clamp(hsl.a);
          return hsla(hsl);
      },
      fade: function (color, amount) {
          var hsl = color.toHSL();
  
          hsl.a = amount.value / 100;
          hsl.a = clamp(hsl.a);
          return hsla(hsl);
      },
      spin: function (color, amount) {
          var hsl = color.toHSL();
          var hue = (hsl.h + amount.value) % 360;
  
          hsl.h = hue < 0 ? 360 + hue : hue;
  
          return hsla(hsl);
      },
      //
      // Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein
      // http://sass-lang.com
      //
      mix: function (color1, color2, weight) {
          if (!weight) {
              weight = new(tree.Dimension)(50);
          }
          var p = weight.value / 100.0;
          var w = p * 2 - 1;
          var a = color1.toHSL().a - color2.toHSL().a;
  
          var w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
          var w2 = 1 - w1;
  
          var rgb = [color1.rgb[0] * w1 + color2.rgb[0] * w2,
                     color1.rgb[1] * w1 + color2.rgb[1] * w2,
                     color1.rgb[2] * w1 + color2.rgb[2] * w2];
  
          var alpha = color1.alpha * p + color2.alpha * (1 - p);
  
          return new(tree.Color)(rgb, alpha);
      },
      greyscale: function (color) {
          return this.desaturate(color, new(tree.Dimension)(100));
      },
      contrast: function (color, dark, light, threshold) {
          // filter: contrast(3.2);
          // should be kept as is, so check for color
          if (!color.rgb) {
              return null;
          }
          if (typeof light === 'undefined') {
              light = this.rgba(255, 255, 255, 1.0);
          }
          if (typeof dark === 'undefined') {
              dark = this.rgba(0, 0, 0, 1.0);
          }
          if (typeof threshold === 'undefined') {
              threshold = 0.43;
          } else {
              threshold = threshold.value;
          }
          if (((0.2126 * (color.rgb[0]/255) + 0.7152 * (color.rgb[1]/255) + 0.0722 * (color.rgb[2]/255)) * color.alpha) < threshold) {
              return light;
          } else {
              return dark;
          }
      },
      e: function (str) {
          return new(tree.Anonymous)(str instanceof tree.JavaScript ? str.evaluated : str);
      },
      escape: function (str) {
          return new(tree.Anonymous)(encodeURI(str.value).replace(/=/g, "%3D").replace(/:/g, "%3A").replace(/#/g, "%23").replace(/;/g, "%3B").replace(/\(/g, "%28").replace(/\)/g, "%29"));
      },
      '%': function (quoted /* arg, arg, ...*/) {
          var args = Array.prototype.slice.call(arguments, 1),
              str = quoted.value;
  
          for (var i = 0; i < args.length; i++) {
              str = str.replace(/%[sda]/i, function(token) {
                  var value = token.match(/s/i) ? args[i].value : args[i].toCSS();
                  return token.match(/[A-Z]$/) ? encodeURIComponent(value) : value;
              });
          }
          str = str.replace(/%%/g, '%');
          return new(tree.Quoted)('"' + str + '"', str);
      },
      unit: function (val, unit) {
          return new(tree.Dimension)(val.value, unit ? unit.toCSS() : "");
      },
      round: function (n, f) {
          var fraction = typeof(f) === "undefined" ? 0 : f.value;
          return this._math(function(num) { return num.toFixed(fraction); }, n);
      },
      ceil: function (n) {
          return this._math(Math.ceil, n);
      },
      floor: function (n) {
          return this._math(Math.floor, n);
      },
      _math: function (fn, n) {
          if (n instanceof tree.Dimension) {
              return new(tree.Dimension)(fn(parseFloat(n.value)), n.unit);
          } else if (typeof(n) === 'number') {
              return fn(n);
          } else {
              throw { type: "Argument", message: "argument must be a number" };
          }
      },
      argb: function (color) {
          return new(tree.Anonymous)(color.toARGB());
  
      },
      percentage: function (n) {
          return new(tree.Dimension)(n.value * 100, '%');
      },
      color: function (n) {
          if (n instanceof tree.Quoted) {
              return new(tree.Color)(n.value.slice(1));
          } else {
              throw { type: "Argument", message: "argument must be a string" };
          }
      },
      iscolor: function (n) {
          return this._isa(n, tree.Color);
      },
      isnumber: function (n) {
          return this._isa(n, tree.Dimension);
      },
      isstring: function (n) {
          return this._isa(n, tree.Quoted);
      },
      iskeyword: function (n) {
          return this._isa(n, tree.Keyword);
      },
      isurl: function (n) {
          return this._isa(n, tree.URL);
      },
      ispixel: function (n) {
          return (n instanceof tree.Dimension) && n.unit === 'px' ? tree.True : tree.False;
      },
      ispercentage: function (n) {
          return (n instanceof tree.Dimension) && n.unit === '%' ? tree.True : tree.False;
      },
      isem: function (n) {
          return (n instanceof tree.Dimension) && n.unit === 'em' ? tree.True : tree.False;
      },
      _isa: function (n, Type) {
          return (n instanceof Type) ? tree.True : tree.False;
      },
      
      /* Blending modes */
      
      multiply: function(color1, color2) {
          var r = color1.rgb[0] * color2.rgb[0] / 255;
          var g = color1.rgb[1] * color2.rgb[1] / 255;
          var b = color1.rgb[2] * color2.rgb[2] / 255;
          return this.rgb(r, g, b);
      },
      screen: function(color1, color2) {
          var r = 255 - (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255;
          var g = 255 - (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255;
          var b = 255 - (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255;
          return this.rgb(r, g, b);
      },
      overlay: function(color1, color2) {
          var r = color1.rgb[0] < 128 ? 2 * color1.rgb[0] * color2.rgb[0] / 255 : 255 - 2 * (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255;
          var g = color1.rgb[1] < 128 ? 2 * color1.rgb[1] * color2.rgb[1] / 255 : 255 - 2 * (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255;
          var b = color1.rgb[2] < 128 ? 2 * color1.rgb[2] * color2.rgb[2] / 255 : 255 - 2 * (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255;
          return this.rgb(r, g, b);
      },
      softlight: function(color1, color2) {
          var t = color2.rgb[0] * color1.rgb[0] / 255;
          var r = t + color1.rgb[0] * (255 - (255 - color1.rgb[0]) * (255 - color2.rgb[0]) / 255 - t) / 255;
          t = color2.rgb[1] * color1.rgb[1] / 255;
          var g = t + color1.rgb[1] * (255 - (255 - color1.rgb[1]) * (255 - color2.rgb[1]) / 255 - t) / 255;
          t = color2.rgb[2] * color1.rgb[2] / 255;
          var b = t + color1.rgb[2] * (255 - (255 - color1.rgb[2]) * (255 - color2.rgb[2]) / 255 - t) / 255;
          return this.rgb(r, g, b);
      },
      hardlight: function(color1, color2) {
          var r = color2.rgb[0] < 128 ? 2 * color2.rgb[0] * color1.rgb[0] / 255 : 255 - 2 * (255 - color2.rgb[0]) * (255 - color1.rgb[0]) / 255;
          var g = color2.rgb[1] < 128 ? 2 * color2.rgb[1] * color1.rgb[1] / 255 : 255 - 2 * (255 - color2.rgb[1]) * (255 - color1.rgb[1]) / 255;
          var b = color2.rgb[2] < 128 ? 2 * color2.rgb[2] * color1.rgb[2] / 255 : 255 - 2 * (255 - color2.rgb[2]) * (255 - color1.rgb[2]) / 255;
          return this.rgb(r, g, b);
      },
      difference: function(color1, color2) {
          var r = Math.abs(color1.rgb[0] - color2.rgb[0]);
          var g = Math.abs(color1.rgb[1] - color2.rgb[1]);
          var b = Math.abs(color1.rgb[2] - color2.rgb[2]);
          return this.rgb(r, g, b);
      },
      exclusion: function(color1, color2) {
          var r = color1.rgb[0] + color2.rgb[0] * (255 - color1.rgb[0] - color1.rgb[0]) / 255;
          var g = color1.rgb[1] + color2.rgb[1] * (255 - color1.rgb[1] - color1.rgb[1]) / 255;
          var b = color1.rgb[2] + color2.rgb[2] * (255 - color1.rgb[2] - color1.rgb[2]) / 255;
          return this.rgb(r, g, b);
      },
      average: function(color1, color2) {
          var r = (color1.rgb[0] + color2.rgb[0]) / 2;
          var g = (color1.rgb[1] + color2.rgb[1]) / 2;
          var b = (color1.rgb[2] + color2.rgb[2]) / 2;
          return this.rgb(r, g, b);
      },
      negation: function(color1, color2) {
          var r = 255 - Math.abs(255 - color2.rgb[0] - color1.rgb[0]);
          var g = 255 - Math.abs(255 - color2.rgb[1] - color1.rgb[1]);
          var b = 255 - Math.abs(255 - color2.rgb[2] - color1.rgb[2]);
          return this.rgb(r, g, b);
      },
      tint: function(color, amount) {
          return this.mix(this.rgb(255,255,255), color, amount);
      },
      shade: function(color, amount) {
          return this.mix(this.rgb(0, 0, 0), color, amount);
      }
  };
  
  function hsla(color) {
      return tree.functions.hsla(color.h, color.s, color.l, color.a);
  }
  
  function scaled(n, size) {
      if (n instanceof tree.Dimension && n.unit == '%') {
          return parseFloat(n.value * size / 100);
      } else {
          return number(n);
      }
  }
  
  function number(n) {
      if (n instanceof tree.Dimension) {
          return parseFloat(n.unit == '%' ? n.value / 100 : n.value);
      } else if (typeof(n) === 'number') {
          return n;
      } else {
          throw {
              error: "RuntimeError",
              message: "color functions take numbers as parameters"
          };
      }
  }
  
  function clamp(val) {
      return Math.min(1, Math.max(0, val));
  }
  
  })(require('./tree'));
  (function (tree) {
      tree.colors = {
          'aliceblue':'#f0f8ff',
          'antiquewhite':'#faebd7',
          'aqua':'#00ffff',
          'aquamarine':'#7fffd4',
          'azure':'#f0ffff',
          'beige':'#f5f5dc',
          'bisque':'#ffe4c4',
          'black':'#000000',
          'blanchedalmond':'#ffebcd',
          'blue':'#0000ff',
          'blueviolet':'#8a2be2',
          'brown':'#a52a2a',
          'burlywood':'#deb887',
          'cadetblue':'#5f9ea0',
          'chartreuse':'#7fff00',
          'chocolate':'#d2691e',
          'coral':'#ff7f50',
          'cornflowerblue':'#6495ed',
          'cornsilk':'#fff8dc',
          'crimson':'#dc143c',
          'cyan':'#00ffff',
          'darkblue':'#00008b',
          'darkcyan':'#008b8b',
          'darkgoldenrod':'#b8860b',
          'darkgray':'#a9a9a9',
          'darkgrey':'#a9a9a9',
          'darkgreen':'#006400',
          'darkkhaki':'#bdb76b',
          'darkmagenta':'#8b008b',
          'darkolivegreen':'#556b2f',
          'darkorange':'#ff8c00',
          'darkorchid':'#9932cc',
          'darkred':'#8b0000',
          'darksalmon':'#e9967a',
          'darkseagreen':'#8fbc8f',
          'darkslateblue':'#483d8b',
          'darkslategray':'#2f4f4f',
          'darkslategrey':'#2f4f4f',
          'darkturquoise':'#00ced1',
          'darkviolet':'#9400d3',
          'deeppink':'#ff1493',
          'deepskyblue':'#00bfff',
          'dimgray':'#696969',
          'dimgrey':'#696969',
          'dodgerblue':'#1e90ff',
          'firebrick':'#b22222',
          'floralwhite':'#fffaf0',
          'forestgreen':'#228b22',
          'fuchsia':'#ff00ff',
          'gainsboro':'#dcdcdc',
          'ghostwhite':'#f8f8ff',
          'gold':'#ffd700',
          'goldenrod':'#daa520',
          'gray':'#808080',
          'grey':'#808080',
          'green':'#008000',
          'greenyellow':'#adff2f',
          'honeydew':'#f0fff0',
          'hotpink':'#ff69b4',
          'indianred':'#cd5c5c',
          'indigo':'#4b0082',
          'ivory':'#fffff0',
          'khaki':'#f0e68c',
          'lavender':'#e6e6fa',
          'lavenderblush':'#fff0f5',
          'lawngreen':'#7cfc00',
          'lemonchiffon':'#fffacd',
          'lightblue':'#add8e6',
          'lightcoral':'#f08080',
          'lightcyan':'#e0ffff',
          'lightgoldenrodyellow':'#fafad2',
          'lightgray':'#d3d3d3',
          'lightgrey':'#d3d3d3',
          'lightgreen':'#90ee90',
          'lightpink':'#ffb6c1',
          'lightsalmon':'#ffa07a',
          'lightseagreen':'#20b2aa',
          'lightskyblue':'#87cefa',
          'lightslategray':'#778899',
          'lightslategrey':'#778899',
          'lightsteelblue':'#b0c4de',
          'lightyellow':'#ffffe0',
          'lime':'#00ff00',
          'limegreen':'#32cd32',
          'linen':'#faf0e6',
          'magenta':'#ff00ff',
          'maroon':'#800000',
          'mediumaquamarine':'#66cdaa',
          'mediumblue':'#0000cd',
          'mediumorchid':'#ba55d3',
          'mediumpurple':'#9370d8',
          'mediumseagreen':'#3cb371',
          'mediumslateblue':'#7b68ee',
          'mediumspringgreen':'#00fa9a',
          'mediumturquoise':'#48d1cc',
          'mediumvioletred':'#c71585',
          'midnightblue':'#191970',
          'mintcream':'#f5fffa',
          'mistyrose':'#ffe4e1',
          'moccasin':'#ffe4b5',
          'navajowhite':'#ffdead',
          'navy':'#000080',
          'oldlace':'#fdf5e6',
          'olive':'#808000',
          'olivedrab':'#6b8e23',
          'orange':'#ffa500',
          'orangered':'#ff4500',
          'orchid':'#da70d6',
          'palegoldenrod':'#eee8aa',
          'palegreen':'#98fb98',
          'paleturquoise':'#afeeee',
          'palevioletred':'#d87093',
          'papayawhip':'#ffefd5',
          'peachpuff':'#ffdab9',
          'peru':'#cd853f',
          'pink':'#ffc0cb',
          'plum':'#dda0dd',
          'powderblue':'#b0e0e6',
          'purple':'#800080',
          'red':'#ff0000',
          'rosybrown':'#bc8f8f',
          'royalblue':'#4169e1',
          'saddlebrown':'#8b4513',
          'salmon':'#fa8072',
          'sandybrown':'#f4a460',
          'seagreen':'#2e8b57',
          'seashell':'#fff5ee',
          'sienna':'#a0522d',
          'silver':'#c0c0c0',
          'skyblue':'#87ceeb',
          'slateblue':'#6a5acd',
          'slategray':'#708090',
          'slategrey':'#708090',
          'snow':'#fffafa',
          'springgreen':'#00ff7f',
          'steelblue':'#4682b4',
          'tan':'#d2b48c',
          'teal':'#008080',
          'thistle':'#d8bfd8',
          'tomato':'#ff6347',
          // 'transparent':'rgba(0,0,0,0)',
          'turquoise':'#40e0d0',
          'violet':'#ee82ee',
          'wheat':'#f5deb3',
          'white':'#ffffff',
          'whitesmoke':'#f5f5f5',
          'yellow':'#ffff00',
          'yellowgreen':'#9acd32'
      };
  })(require('./tree'));
  (function (tree) {
  
  tree.Alpha = function (val) {
      this.value = val;
  };
  tree.Alpha.prototype = {
      toCSS: function () {
          return "alpha(opacity=" +
                 (this.value.toCSS ? this.value.toCSS() : this.value) + ")";
      },
      eval: function (env) {
          if (this.value.eval) { this.value = this.value.eval(env) }
          return this;
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Anonymous = function (string) {
      this.value = string.value || string;
  };
  tree.Anonymous.prototype = {
      toCSS: function () {
          return this.value;
      },
      eval: function () { return this },
      compare: function (x) {
          if (!x.toCSS) {
              return -1;
          }
          
          var left = this.toCSS(),
              right = x.toCSS();
          
          if (left === right) {
              return 0;
          }
          
          return left < right ? -1 : 1;
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Assignment = function (key, val) {
      this.key = key;
      this.value = val;
  };
  tree.Assignment.prototype = {
      toCSS: function () {
          return this.key + '=' + (this.value.toCSS ? this.value.toCSS() : this.value);
      },
      eval: function (env) {
          if (this.value.eval) {
              return new(tree.Assignment)(this.key, this.value.eval(env));
          }
          return this;
      }
  };
  
  })(require('../tree'));(function (tree) {
  
  //
  // A function call node.
  //
  tree.Call = function (name, args, index, filename) {
      this.name = name;
      this.args = args;
      this.index = index;
      this.filename = filename;
  };
  tree.Call.prototype = {
      //
      // When evaluating a function call,
      // we either find the function in `tree.functions` [1],
      // in which case we call it, passing the  evaluated arguments,
      // if this returns null or we cannot find the function, we 
      // simply print it out as it appeared originally [2].
      //
      // The *functions.js* file contains the built-in functions.
      //
      // The reason why we evaluate the arguments, is in the case where
      // we try to pass a variable to a function, like: `saturate(@color)`.
      // The function should receive the value, not the variable.
      //
      eval: function (env) {
          var args = this.args.map(function (a) { return a.eval(env) }),
              result;
  
          if (this.name in tree.functions) { // 1.
              try {
                  result = tree.functions[this.name].apply(tree.functions, args);
                  if (result != null) {
                      return result;
                  }
              } catch (e) {
                  throw { type: e.type || "Runtime",
                          message: "error evaluating function `" + this.name + "`" +
                                   (e.message ? ': ' + e.message : ''),
                          index: this.index, filename: this.filename };
              }
          }
          
          // 2.
          return new(tree.Anonymous)(this.name +
              "(" + args.map(function (a) { return a.toCSS(env) }).join(', ') + ")");
      },
  
      toCSS: function (env) {
          return this.eval(env).toCSS();
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  //
  // RGB Colors - #ff0014, #eee
  //
  tree.Color = function (rgb, a) {
      //
      // The end goal here, is to parse the arguments
      // into an integer triplet, such as `128, 255, 0`
      //
      // This facilitates operations and conversions.
      //
      if (Array.isArray(rgb)) {
          this.rgb = rgb;
      } else if (rgb.length == 6) {
          this.rgb = rgb.match(/.{2}/g).map(function (c) {
              return parseInt(c, 16);
          });
      } else {
          this.rgb = rgb.split('').map(function (c) {
              return parseInt(c + c, 16);
          });
      }
      this.alpha = typeof(a) === 'number' ? a : 1;
  };
  tree.Color.prototype = {
      eval: function () { return this },
  
      //
      // If we have some transparency, the only way to represent it
      // is via `rgba`. Otherwise, we use the hex representation,
      // which has better compatibility with older browsers.
      // Values are capped between `0` and `255`, rounded and zero-padded.
      //
      toCSS: function () {
          if (this.alpha < 1.0) {
              return "rgba(" + this.rgb.map(function (c) {
                  return Math.round(c);
              }).concat(this.alpha).join(', ') + ")";
          } else {
              return '#' + this.rgb.map(function (i) {
                  i = Math.round(i);
                  i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16);
                  return i.length === 1 ? '0' + i : i;
              }).join('');
          }
      },
  
      //
      // Operations have to be done per-channel, if not,
      // channels will spill onto each other. Once we have
      // our result, in the form of an integer triplet,
      // we create a new Color node to hold the result.
      //
      operate: function (op, other) {
          var result = [];
  
          if (! (other instanceof tree.Color)) {
              other = other.toColor();
          }
  
          for (var c = 0; c < 3; c++) {
              result[c] = tree.operate(op, this.rgb[c], other.rgb[c]);
          }
          return new(tree.Color)(result, this.alpha + other.alpha);
      },
  
      toHSL: function () {
          var r = this.rgb[0] / 255,
              g = this.rgb[1] / 255,
              b = this.rgb[2] / 255,
              a = this.alpha;
  
          var max = Math.max(r, g, b), min = Math.min(r, g, b);
          var h, s, l = (max + min) / 2, d = max - min;
  
          if (max === min) {
              h = s = 0;
          } else {
              s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
  
              switch (max) {
                  case r: h = (g - b) / d + (g < b ? 6 : 0); break;
                  case g: h = (b - r) / d + 2;               break;
                  case b: h = (r - g) / d + 4;               break;
              }
              h /= 6;
          }
          return { h: h * 360, s: s, l: l, a: a };
      },
      toARGB: function () {
          var argb = [Math.round(this.alpha * 255)].concat(this.rgb);
          return '#' + argb.map(function (i) {
              i = Math.round(i);
              i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16);
              return i.length === 1 ? '0' + i : i;
          }).join('');
      },
      compare: function (x) {
          if (!x.rgb) {
              return -1;
          }
          
          return (x.rgb[0] === this.rgb[0] &&
              x.rgb[1] === this.rgb[1] &&
              x.rgb[2] === this.rgb[2] &&
              x.alpha === this.alpha) ? 0 : -1;
      }
  };
  
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Comment = function (value, silent) {
      this.value = value;
      this.silent = !!silent;
  };
  tree.Comment.prototype = {
      toCSS: function (env) {
          return env.compress ? '' : this.value;
      },
      eval: function () { return this }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Condition = function (op, l, r, i, negate) {
      this.op = op.trim();
      this.lvalue = l;
      this.rvalue = r;
      this.index = i;
      this.negate = negate;
  };
  tree.Condition.prototype.eval = function (env) {
      var a = this.lvalue.eval(env),
          b = this.rvalue.eval(env);
  
      var i = this.index, result;
  
      var result = (function (op) {
          switch (op) {
              case 'and':
                  return a && b;
              case 'or':
                  return a || b;
              default:
                  if (a.compare) {
                      result = a.compare(b);
                  } else if (b.compare) {
                      result = b.compare(a);
                  } else {
                      throw { type: "Type",
                              message: "Unable to perform comparison",
                              index: i };
                  }
                  switch (result) {
                      case -1: return op === '<' || op === '=<';
                      case  0: return op === '=' || op === '>=' || op === '=<';
                      case  1: return op === '>' || op === '>=';
                  }
          }
      })(this.op);
      return this.negate ? !result : result;
  };
  
  })(require('../tree'));
  (function (tree) {
  
  //
  // A number with a unit
  //
  tree.Dimension = function (value, unit) {
      this.value = parseFloat(value);
      this.unit = unit || null;
  };
  
  tree.Dimension.prototype = {
      eval: function () { return this },
      toColor: function () {
          return new(tree.Color)([this.value, this.value, this.value]);
      },
      toCSS: function () {
          var css = this.value + this.unit;
          return css;
      },
  
      // In an operation between two Dimensions,
      // we default to the first Dimension's unit,
      // so `1px + 2em` will yield `3px`.
      // In the future, we could implement some unit
      // conversions such that `100cm + 10mm` would yield
      // `101cm`.
      operate: function (op, other) {
          return new(tree.Dimension)
                    (tree.operate(op, this.value, other.value),
                    this.unit || other.unit);
      },
  
      compare: function (other) {
          if (other instanceof tree.Dimension) {
              if (other.value > this.value) {
                  return -1;
              } else if (other.value < this.value) {
                  return 1;
              } else {
                  if (other.unit && this.unit !== other.unit) {
                      return -1;
                  }
                  return 0;
              }
          } else {
              return -1;
          }
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Directive = function (name, value) {
      this.name = name;
  
      if (Array.isArray(value)) {
          this.ruleset = new(tree.Ruleset)([], value);
          this.ruleset.allowImports = true;
      } else {
          this.value = value;
      }
  };
  tree.Directive.prototype = {
      toCSS: function (ctx, env) {
          if (this.ruleset) {
              this.ruleset.root = true;
              return this.name + (env.compress ? '{' : ' {\n  ') +
                     this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
                                 (env.compress ? '}': '\n}\n');
          } else {
              return this.name + ' ' + this.value.toCSS() + ';\n';
          }
      },
      eval: function (env) {
          var evaldDirective = this;
          if (this.ruleset) {
              env.frames.unshift(this);
              evaldDirective = new(tree.Directive)(this.name);
              evaldDirective.ruleset = this.ruleset.eval(env);
              env.frames.shift();
          }
          return evaldDirective;
      },
      variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) },
      find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
      rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Element = function (combinator, value, index) {
      this.combinator = combinator instanceof tree.Combinator ?
                        combinator : new(tree.Combinator)(combinator);
  
      if (typeof(value) === 'string') {
          this.value = value.trim();
      } else if (value) {
          this.value = value;
      } else {
          this.value = "";
      }
      this.index = index;
  };
  tree.Element.prototype.eval = function (env) {
      return new(tree.Element)(this.combinator,
                               this.value.eval ? this.value.eval(env) : this.value,
                               this.index);
  };
  tree.Element.prototype.toCSS = function (env) {
  	var value = (this.value.toCSS ? this.value.toCSS(env) : this.value);
  	if (value == '' && this.combinator.value.charAt(0) == '&') {
  		return '';
  	} else {
  		return this.combinator.toCSS(env || {}) + value;
  	}
  };
  
  tree.Combinator = function (value) {
      if (value === ' ') {
          this.value = ' ';
      } else {
          this.value = value ? value.trim() : "";
      }
  };
  tree.Combinator.prototype.toCSS = function (env) {
      return {
          ''  : '',
          ' ' : ' ',
          ':' : ' :',
          '+' : env.compress ? '+' : ' + ',
          '~' : env.compress ? '~' : ' ~ ',
          '>' : env.compress ? '>' : ' > ',
          '|' : env.compress ? '|' : ' | '
      }[this.value];
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Expression = function (value) { this.value = value };
  tree.Expression.prototype = {
      eval: function (env) {
          if (this.value.length > 1) {
              return new(tree.Expression)(this.value.map(function (e) {
                  return e.eval(env);
              }));
          } else if (this.value.length === 1) {
              return this.value[0].eval(env);
          } else {
              return this;
          }
      },
      toCSS: function (env) {
          return this.value.map(function (e) {
              return e.toCSS ? e.toCSS(env) : '';
          }).join(' ');
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  //
  // CSS @import node
  //
  // The general strategy here is that we don't want to wait
  // for the parsing to be completed, before we start importing
  // the file. That's because in the context of a browser,
  // most of the time will be spent waiting for the server to respond.
  //
  // On creation, we push the import path to our import queue, though
  // `import,push`, we also pass it a callback, which it'll call once
  // the file has been fetched, and parsed.
  //
  tree.Import = function (path, imports, features, once, index, rootpath) {
      var that = this;
  
      this.once = once;
      this.index = index;
      this._path = path;
      this.features = features && new(tree.Value)(features);
      this.rootpath = rootpath;
  		
      // The '.less' extension is optional
      if (path instanceof tree.Quoted) {
          this.path = /(\.[a-z]*$)|([\?;].*)$/.test(path.value) ? path.value : path.value + '.less';
      } else {
          this.path = path.value.value || path.value;
      }
  
      this.css = /css([\?;].*)?$/.test(this.path);
  
      // Only pre-compile .less files
      if (! this.css) {
          imports.push(this.path, function (e, root, imported) {
              if (e) { e.index = index }
              if (imported && that.once) that.skip = imported;
              that.root = root || new(tree.Ruleset)([], []);
          });
      }
  };
  
  //
  // The actual import node doesn't return anything, when converted to CSS.
  // The reason is that it's used at the evaluation stage, so that the rules
  // it imports can be treated like any other rules.
  //
  // In `eval`, we make sure all Import nodes get evaluated, recursively, so
  // we end up with a flat structure, which can easily be imported in the parent
  // ruleset.
  //
  tree.Import.prototype = {
      toCSS: function (env) {
          var features = this.features ? ' ' + this.features.toCSS(env) : '';
  
          if (this.css) {
              // Add the base path if the import is relative
              if (typeof this._path.value === "string" && !/^(?:[a-z-]+:|\/)/.test(this._path.value)) {
                  this._path.value = this.rootpath + this._path.value;
              }
              return "@import " + this._path.toCSS() + features + ';\n';
          } else {
              return "";
          }
      },
      eval: function (env) {
          var ruleset, features = this.features && this.features.eval(env);
  
          if (this.skip) return [];
  
          if (this.css) {
              return this;
          } else {
              ruleset = new(tree.Ruleset)([], this.root.rules.slice(0));
  
              ruleset.evalImports(env);
  
              return this.features ? new(tree.Media)(ruleset.rules, this.features.value) : ruleset.rules;
          }
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.JavaScript = function (string, index, escaped) {
      this.escaped = escaped;
      this.expression = string;
      this.index = index;
  };
  tree.JavaScript.prototype = {
      eval: function (env) {
          var result,
              that = this,
              context = {};
  
          var expression = this.expression.replace(/@\{([\w-]+)\}/g, function (_, name) {
              return tree.jsify(new(tree.Variable)('@' + name, that.index).eval(env));
          });
  
          try {
              expression = new(Function)('return (' + expression + ')');
          } catch (e) {
              throw { message: "JavaScript evaluation error: `" + expression + "`" ,
                      index: this.index };
          }
  
          for (var k in env.frames[0].variables()) {
              context[k.slice(1)] = {
                  value: env.frames[0].variables()[k].value,
                  toJS: function () {
                      return this.value.eval(env).toCSS();
                  }
              };
          }
  
          try {
              result = expression.call(context);
          } catch (e) {
              throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message + "'" ,
                      index: this.index };
          }
          if (typeof(result) === 'string') {
              return new(tree.Quoted)('"' + result + '"', result, this.escaped, this.index);
          } else if (Array.isArray(result)) {
              return new(tree.Anonymous)(result.join(', '));
          } else {
              return new(tree.Anonymous)(result);
          }
      }
  };
  
  })(require('../tree'));
  
  (function (tree) {
  
  tree.Keyword = function (value) { this.value = value };
  tree.Keyword.prototype = {
      eval: function () { return this },
      toCSS: function () { return this.value },
      compare: function (other) {
          if (other instanceof tree.Keyword) {
              return other.value === this.value ? 0 : 1;
          } else {
              return -1;
          }
      }
  };
  
  tree.True = new(tree.Keyword)('true');
  tree.False = new(tree.Keyword)('false');
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Media = function (value, features) {
      var selectors = this.emptySelectors();
  
      this.features = new(tree.Value)(features);
      this.ruleset = new(tree.Ruleset)(selectors, value);
      this.ruleset.allowImports = true;
  };
  tree.Media.prototype = {
      toCSS: function (ctx, env) {
          var features = this.features.toCSS(env);
  
          this.ruleset.root = (ctx.length === 0 || ctx[0].multiMedia);
          return '@media ' + features + (env.compress ? '{' : ' {\n  ') +
                 this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
                             (env.compress ? '}': '\n}\n');
      },
      eval: function (env) {
          if (!env.mediaBlocks) {
              env.mediaBlocks = [];
              env.mediaPath = [];
          }
          
          var media = new(tree.Media)([], []);
          if(this.debugInfo) {
              this.ruleset.debugInfo = this.debugInfo;
              media.debugInfo = this.debugInfo;
          }
          media.features = this.features.eval(env);
          
          env.mediaPath.push(media);
          env.mediaBlocks.push(media);
          
          env.frames.unshift(this.ruleset);
          media.ruleset = this.ruleset.eval(env);
          env.frames.shift();
          
          env.mediaPath.pop();
  
          return env.mediaPath.length === 0 ? media.evalTop(env) :
                      media.evalNested(env)
      },
      variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) },
      find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
      rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) },
      emptySelectors: function() { 
          var el = new(tree.Element)('', '&', 0);
          return [new(tree.Selector)([el])];
      },
  
      evalTop: function (env) {
          var result = this;
  
          // Render all dependent Media blocks.
          if (env.mediaBlocks.length > 1) {
              var selectors = this.emptySelectors();
              result = new(tree.Ruleset)(selectors, env.mediaBlocks);
              result.multiMedia = true;
          }
  
          delete env.mediaBlocks;
          delete env.mediaPath;
  
          return result;
      },
      evalNested: function (env) {
          var i, value,
              path = env.mediaPath.concat([this]);
  
          // Extract the media-query conditions separated with `,` (OR).
          for (i = 0; i < path.length; i++) {
              value = path[i].features instanceof tree.Value ?
                          path[i].features.value : path[i].features;
              path[i] = Array.isArray(value) ? value : [value];
          }
  
          // Trace all permutations to generate the resulting media-query.
          //
          // (a, b and c) with nested (d, e) ->
          //    a and d
          //    a and e
          //    b and c and d
          //    b and c and e
          this.features = new(tree.Value)(this.permute(path).map(function (path) {
              path = path.map(function (fragment) {
                  return fragment.toCSS ? fragment : new(tree.Anonymous)(fragment);
              });
  
              for(i = path.length - 1; i > 0; i--) {
                  path.splice(i, 0, new(tree.Anonymous)("and"));
              }
  
              return new(tree.Expression)(path);
          }));
  
          // Fake a tree-node that doesn't output anything.
          return new(tree.Ruleset)([], []);
      },
      permute: function (arr) {
        if (arr.length === 0) {
            return [];
        } else if (arr.length === 1) {
            return arr[0];
        } else {
            var result = [];
            var rest = this.permute(arr.slice(1));
            for (var i = 0; i < rest.length; i++) {
                for (var j = 0; j < arr[0].length; j++) {
                    result.push([arr[0][j]].concat(rest[i]));
                }
            }
            return result;
        }
      },
      bubbleSelectors: function (selectors) {
        this.ruleset = new(tree.Ruleset)(selectors.slice(0), [this.ruleset]);
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.mixin = {};
  tree.mixin.Call = function (elements, args, index, filename, important) {
      this.selector = new(tree.Selector)(elements);
      this.arguments = args;
      this.index = index;
      this.filename = filename;
      this.important = important;
  };
  tree.mixin.Call.prototype = {
      eval: function (env) {
          var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound;
  
          args = this.arguments && this.arguments.map(function (a) {
              return { name: a.name, value: a.value.eval(env) };
          });
  
          for (i = 0; i < env.frames.length; i++) {
              if ((mixins = env.frames[i].find(this.selector)).length > 0) {
                  isOneFound = true;
                  for (m = 0; m < mixins.length; m++) {
                      mixin = mixins[m];
                      isRecursive = false;
                      for(f = 0; f < env.frames.length; f++) {
                          if ((!(mixin instanceof tree.mixin.Definition)) && mixin === (env.frames[f].originalRuleset || env.frames[f])) {
                              isRecursive = true;
                              break;
                          }
                      }
                      if (isRecursive) {
                          continue;
                      }
                      if (mixin.matchArgs(args, env)) {
                          if (!mixin.matchCondition || mixin.matchCondition(args, env)) {
                              try {
                                  Array.prototype.push.apply(
                                        rules, mixin.eval(env, args, this.important).rules);
                              } catch (e) {
                                  throw { message: e.message, index: this.index, filename: this.filename, stack: e.stack };
                              }
                          }
                          match = true;
                      }
                  }
                  if (match) {
                      return rules;
                  }
              }
          }
          if (isOneFound) {
              throw { type:    'Runtime',
                      message: 'No matching definition was found for `' +
                                this.selector.toCSS().trim() + '('      +
                                (args ? args.map(function (a) {
                                    var argValue = "";
                                    if (a.name) {
                                        argValue += a.name + ":";
                                    }
                                    if (a.value.toCSS) {
                                        argValue += a.value.toCSS();
                                    } else {
                                        argValue += "???";
                                    }
                                    return argValue;
                                }).join(', ') : "") + ")`",
                      index:   this.index, filename: this.filename };
          } else {
              throw { type: 'Name',
                  message: this.selector.toCSS().trim() + " is undefined",
                  index: this.index, filename: this.filename };
          }
      }
  };
  
  tree.mixin.Definition = function (name, params, rules, condition, variadic) {
      this.name = name;
      this.selectors = [new(tree.Selector)([new(tree.Element)(null, name)])];
      this.params = params;
      this.condition = condition;
      this.variadic = variadic;
      this.arity = params.length;
      this.rules = rules;
      this._lookups = {};
      this.required = params.reduce(function (count, p) {
          if (!p.name || (p.name && !p.value)) { return count + 1 }
          else                                 { return count }
      }, 0);
      this.parent = tree.Ruleset.prototype;
      this.frames = [];
  };
  tree.mixin.Definition.prototype = {
      toCSS:     function ()     { return "" },
      variable:  function (name) { return this.parent.variable.call(this, name) },
      variables: function ()     { return this.parent.variables.call(this) },
      find:      function ()     { return this.parent.find.apply(this, arguments) },
      rulesets:  function ()     { return this.parent.rulesets.apply(this) },
  
      evalParams: function (env, mixinEnv, args, evaldArguments) {
          var frame = new(tree.Ruleset)(null, []), varargs, arg, params = this.params.slice(0), i, j, val, name, isNamedFound, argIndex;
          
          if (args) {
              args = args.slice(0);
  
              for(i = 0; i < args.length; i++) {
                  arg = args[i];
                  if (name = (arg && arg.name)) {
                      isNamedFound = false;
                      for(j = 0; j < params.length; j++) {
                          if (!evaldArguments[j] && name === params[j].name) {
                              evaldArguments[j] = arg.value.eval(env);
                              frame.rules.unshift(new(tree.Rule)(name, arg.value.eval(env)));
                              isNamedFound = true;
                              break;
                          }
                      }
                      if (isNamedFound) {
                          args.splice(i, 1);
                          i--;
                          continue;
                      } else {
                          throw { type: 'Runtime', message: "Named argument for " + this.name +
                              ' ' + args[i].name + ' not found' };
                      }
                  }
              }
          }
          argIndex = 0;
          for (i = 0; i < params.length; i++) {
              if (evaldArguments[i]) continue;
              
              arg = args && args[argIndex];
  
              if (name = params[i].name) {
                  if (params[i].variadic && args) {
                      varargs = [];
                      for (j = argIndex; j < args.length; j++) {
                          varargs.push(args[j].value.eval(env));
                      }
                      frame.rules.unshift(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
                  } else {
                      val = arg && arg.value;
                      if (val) {
                          val = val.eval(env);
                      } else if (params[i].value) {
                          val = params[i].value.eval(mixinEnv);
                      } else {
                          throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
                              ' (' + args.length + ' for ' + this.arity + ')' };
                      }
                      
                      frame.rules.unshift(new(tree.Rule)(name, val));
                      evaldArguments[i] = val;
                  }
              }
              
              if (params[i].variadic && args) {
                  for (j = argIndex; j < args.length; j++) {
                      evaldArguments[j] = args[j].value.eval(env);
                  }
              }
              argIndex++;
          }
  
          return frame;
      },
      eval: function (env, args, important) {
          var _arguments = [],
              mixinFrames = this.frames.concat(env.frames),
              frame = this.evalParams(env, {frames: mixinFrames}, args, _arguments), 
              context, rules, start, ruleset;
  
          frame.rules.unshift(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env)));
  
          rules = important ?
              this.parent.makeImportant.apply(this).rules : this.rules.slice(0);
  
          ruleset = new(tree.Ruleset)(null, rules).eval({
              frames: [this, frame].concat(mixinFrames)
          });
          ruleset.originalRuleset = this;
          return ruleset;
      },
      matchCondition: function (args, env) {
          if (this.condition && !this.condition.eval({
              frames: [this.evalParams(env, {frames: this.frames.concat(env.frames)}, args, [])].concat(env.frames)
          }))                                                           { return false }
          return true;
      },
      matchArgs: function (args, env) {
          var argsLength = (args && args.length) || 0, len, frame;
  
          if (! this.variadic) {
              if (argsLength < this.required)                               { return false }
              if (argsLength > this.params.length)                          { return false }
              if ((this.required > 0) && (argsLength > this.params.length)) { return false }
          }
  
          len = Math.min(argsLength, this.arity);
  
          for (var i = 0; i < len; i++) {
              if (!this.params[i].name && !this.params[i].variadic) {
                  if (args[i].value.eval(env).toCSS() != this.params[i].value.eval(env).toCSS()) {
                      return false;
                  }
              }
          }
          return true;
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Operation = function (op, operands) {
      this.op = op.trim();
      this.operands = operands;
  };
  tree.Operation.prototype.eval = function (env) {
      var a = this.operands[0].eval(env),
          b = this.operands[1].eval(env),
          temp;
  
      if (a instanceof tree.Dimension && b instanceof tree.Color) {
          if (this.op === '*' || this.op === '+') {
              temp = b, b = a, a = temp;
          } else {
              throw { name: "OperationError",
                      message: "Can't substract or divide a color from a number" };
          }
      }
      if (!a.operate) {
          throw { name: "OperationError",
                  message: "Operation on an invalid type" };
      }
  
      return a.operate(this.op, b);
  };
  
  tree.operate = function (op, a, b) {
      switch (op) {
          case '+': return a + b;
          case '-': return a - b;
          case '*': return a * b;
          case '/': return a / b;
      }
  };
  
  })(require('../tree'));
  
  (function (tree) {
  
  tree.Paren = function (node) {
      this.value = node;
  };
  tree.Paren.prototype = {
      toCSS: function (env) {
          return '(' + this.value.toCSS(env) + ')';
      },
      eval: function (env) {
          return new(tree.Paren)(this.value.eval(env));
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Quoted = function (str, content, escaped, i) {
      this.escaped = escaped;
      this.value = content || '';
      this.quote = str.charAt(0);
      this.index = i;
  };
  tree.Quoted.prototype = {
      toCSS: function () {
          if (this.escaped) {
              return this.value;
          } else {
              return this.quote + this.value + this.quote;
          }
      },
      eval: function (env) {
          var that = this;
          var value = this.value.replace(/`([^`]+)`/g, function (_, exp) {
              return new(tree.JavaScript)(exp, that.index, true).eval(env).value;
          }).replace(/@\{([\w-]+)\}/g, function (_, name) {
              var v = new(tree.Variable)('@' + name, that.index).eval(env);
              return (v instanceof tree.Quoted) ? v.value : v.toCSS();
          });
          return new(tree.Quoted)(this.quote + value + this.quote, value, this.escaped, this.index);
      },
      compare: function (x) {
          if (!x.toCSS) {
              return -1;
          }
          
          var left = this.toCSS(),
              right = x.toCSS();
          
          if (left === right) {
              return 0;
          }
          
          return left < right ? -1 : 1;
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Ratio = function (value) {
      this.value = value;
  };
  tree.Ratio.prototype = {
      toCSS: function (env) {
          return this.value;
      },
      eval: function () { return this }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Rule = function (name, value, important, index, inline) {
      this.name = name;
      this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]);
      this.important = important ? ' ' + important.trim() : '';
      this.index = index;
      this.inline = inline || false;
  
      if (name.charAt(0) === '@') {
          this.variable = true;
      } else { this.variable = false }
  };
  tree.Rule.prototype.toCSS = function (env) {
      if (this.variable) { return "" }
      else {
          return this.name + (env.compress ? ':' : ': ') +
                 this.value.toCSS(env) +
                 this.important + (this.inline ? "" : ";");
      }
  };
  
  tree.Rule.prototype.eval = function (context) {
      return new(tree.Rule)(this.name,
                            this.value.eval(context),
                            this.important,
                            this.index, this.inline);
  };
  
  tree.Rule.prototype.makeImportant = function () {
      return new(tree.Rule)(this.name,
                            this.value,
                            "!important",
                            this.index, this.inline);
  };
  
  tree.Shorthand = function (a, b) {
      this.a = a;
      this.b = b;
  };
  
  tree.Shorthand.prototype = {
      toCSS: function (env) {
          return this.a.toCSS(env) + "/" + this.b.toCSS(env);
      },
      eval: function () { return this }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Ruleset = function (selectors, rules, strictImports) {
      this.selectors = selectors;
      this.rules = rules;
      this._lookups = {};
      this.strictImports = strictImports;
  };
  tree.Ruleset.prototype = {
      eval: function (env) {
          var selectors = this.selectors && this.selectors.map(function (s) { return s.eval(env) });
          var ruleset = new(tree.Ruleset)(selectors, this.rules.slice(0), this.strictImports);
          var rules;
          
          ruleset.originalRuleset = this;
          ruleset.root = this.root;
          ruleset.allowImports = this.allowImports;
  
          if(this.debugInfo) {
              ruleset.debugInfo = this.debugInfo;
          }
  
          // push the current ruleset to the frames stack
          env.frames.unshift(ruleset);
  
          // Evaluate imports
          if (ruleset.root || ruleset.allowImports || !ruleset.strictImports) {
              ruleset.evalImports(env);
          }
  
          // Store the frames around mixin definitions,
          // so they can be evaluated like closures when the time comes.
          for (var i = 0; i < ruleset.rules.length; i++) {
              if (ruleset.rules[i] instanceof tree.mixin.Definition) {
                  ruleset.rules[i].frames = env.frames.slice(0);
              }
          }
          
          var mediaBlockCount = (env.mediaBlocks && env.mediaBlocks.length) || 0;
  
          // Evaluate mixin calls.
          for (var i = 0; i < ruleset.rules.length; i++) {
              if (ruleset.rules[i] instanceof tree.mixin.Call) {
                  rules = ruleset.rules[i].eval(env);
                  ruleset.rules.splice.apply(ruleset.rules, [i, 1].concat(rules));
                  i += rules.length-1;
                  ruleset.resetCache();
              }
          }
  
          // Evaluate everything else
          for (var i = 0, rule; i < ruleset.rules.length; i++) {
              rule = ruleset.rules[i];
  
              if (! (rule instanceof tree.mixin.Definition)) {
                  ruleset.rules[i] = rule.eval ? rule.eval(env) : rule;
              }
          }
  
          // Pop the stack
          env.frames.shift();
          
          if (env.mediaBlocks) {
              for(var i = mediaBlockCount; i < env.mediaBlocks.length; i++) {
                  env.mediaBlocks[i].bubbleSelectors(selectors);
              }
          }
  
          return ruleset;
      },
      evalImports: function(env) {
          var i, rules;
          for (i = 0; i < this.rules.length; i++) {
              if (this.rules[i] instanceof tree.Import) {
                  rules = this.rules[i].eval(env);
                  if (typeof rules.length === "number") {
                      this.rules.splice.apply(this.rules, [i, 1].concat(rules));
                      i+= rules.length-1;
                  } else {
                      this.rules.splice(i, 1, rules);
                  }
                  this.resetCache();
              }
          }
      },
      makeImportant: function() {
          return new tree.Ruleset(this.selectors, this.rules.map(function (r) {
                      if (r.makeImportant) {
                          return r.makeImportant();
                      } else {
                          return r;
                      }
                  }), this.strictImports);
      },
      matchArgs: function (args) {
          return !args || args.length === 0;
      },
      resetCache: function () {
          this._rulesets = null;
          this._variables = null;
          this._lookups = {};
      },
      variables: function () {
          if (this._variables) { return this._variables }
          else {
              return this._variables = this.rules.reduce(function (hash, r) {
                  if (r instanceof tree.Rule && r.variable === true) {
                      hash[r.name] = r;
                  }
                  return hash;
              }, {});
          }
      },
      variable: function (name) {
          return this.variables()[name];
      },
      rulesets: function () {
          if (this._rulesets) { return this._rulesets }
          else {
              return this._rulesets = this.rules.filter(function (r) {
                  return (r instanceof tree.Ruleset) || (r instanceof tree.mixin.Definition);
              });
          }
      },
      find: function (selector, self) {
          self = self || this;
          var rules = [], rule, match,
              key = selector.toCSS();
  
          if (key in this._lookups) { return this._lookups[key] }
  
          this.rulesets().forEach(function (rule) {
              if (rule !== self) {
                  for (var j = 0; j < rule.selectors.length; j++) {
                      if (match = selector.match(rule.selectors[j])) {
                          if (selector.elements.length > rule.selectors[j].elements.length) {
                              Array.prototype.push.apply(rules, rule.find(
                                  new(tree.Selector)(selector.elements.slice(1)), self));
                          } else {
                              rules.push(rule);
                          }
                          break;
                      }
                  }
              }
          });
          return this._lookups[key] = rules;
      },
      //
      // Entry point for code generation
      //
      //     `context` holds an array of arrays.
      //
      toCSS: function (context, env) {
          var css = [],      // The CSS output
              rules = [],    // node.Rule instances
             _rules = [],    //
              rulesets = [], // node.Ruleset instances
              paths = [],    // Current selectors
              selector,      // The fully rendered selector
              debugInfo,     // Line number debugging
              rule;
  
          if (! this.root) {
              this.joinSelectors(paths, context, this.selectors);
          }
  
          // Compile rules and rulesets
          for (var i = 0; i < this.rules.length; i++) {
              rule = this.rules[i];
  
              if (rule.rules || (rule instanceof tree.Media)) {
                  rulesets.push(rule.toCSS(paths, env));
              } else if (rule instanceof tree.Directive) {
                  var cssValue = rule.toCSS(paths, env);
                  // Output only the first @charset definition as such - convert the others
                  // to comments in case debug is enabled
                  if (rule.name === "@charset") {
                      // Only output the debug info together with subsequent @charset definitions
                      // a comment (or @media statement) before the actual @charset directive would
                      // be considered illegal css as it has to be on the first line
                      if (env.charset) {
                          if (rule.debugInfo) {
                              rulesets.push(tree.debugInfo(env, rule));
                              rulesets.push(new tree.Comment("/* "+cssValue.replace(/\n/g, "")+" */\n").toCSS(env));
                          }
                          continue;
                      }
                      env.charset = true;
                  }
                  rulesets.push(cssValue);
              } else if (rule instanceof tree.Comment) {
                  if (!rule.silent) {
                      if (this.root) {
                          rulesets.push(rule.toCSS(env));
                      } else {
                          rules.push(rule.toCSS(env));
                      }
                  }
              } else {
                  if (rule.toCSS && !rule.variable) {
                      rules.push(rule.toCSS(env));
                  } else if (rule.value && !rule.variable) {
                      rules.push(rule.value.toString());
                  }
              }
          } 
  
          rulesets = rulesets.join('');
  
          // If this is the root node, we don't render
          // a selector, or {}.
          // Otherwise, only output if this ruleset has rules.
          if (this.root) {
              css.push(rules.join(env.compress ? '' : '\n'));
          } else {
              if (rules.length > 0) {
                  debugInfo = tree.debugInfo(env, this);
                  selector = paths.map(function (p) {
                      return p.map(function (s) {
                          return s.toCSS(env);
                      }).join('').trim();
                  }).join(env.compress ? ',' : ',\n');
  
                  // Remove duplicates
                  for (var i = rules.length - 1; i >= 0; i--) {
                      if (_rules.indexOf(rules[i]) === -1) {
                          _rules.unshift(rules[i]);
                      }
                  }
                  rules = _rules;
  
                  css.push(debugInfo + selector + 
                          (env.compress ? '{' : ' {\n  ') +
                          rules.join(env.compress ? '' : '\n  ') +
                          (env.compress ? '}' : '\n}\n'));
              }
          }
          css.push(rulesets);
  
          return css.join('')  + (env.compress ? '\n' : '');
      },
  
      joinSelectors: function (paths, context, selectors) {
          for (var s = 0; s < selectors.length; s++) {
              this.joinSelector(paths, context, selectors[s]);
          }
      },
  
      joinSelector: function (paths, context, selector) {
  
          var i, j, k, 
              hasParentSelector, newSelectors, el, sel, parentSel, 
              newSelectorPath, afterParentJoin, newJoinedSelector, 
              newJoinedSelectorEmpty, lastSelector, currentElements,
              selectorsMultiplied;
      
          for (i = 0; i < selector.elements.length; i++) {
              el = selector.elements[i];
              if (el.value === '&') {
                  hasParentSelector = true;
              }
          }
      
          if (!hasParentSelector) {
              if (context.length > 0) {
                  for(i = 0; i < context.length; i++) {
                      paths.push(context[i].concat(selector));
                  }
              }
              else {
                  paths.push([selector]);
              }
              return;
          }
  
          // The paths are [[Selector]]
          // The first list is a list of comma seperated selectors
          // The inner list is a list of inheritance seperated selectors
          // e.g.
          // .a, .b {
          //   .c {
          //   }
          // }
          // == [[.a] [.c]] [[.b] [.c]]
          //
  
          // the elements from the current selector so far
          currentElements = [];
          // the current list of new selectors to add to the path.
          // We will build it up. We initiate it with one empty selector as we "multiply" the new selectors
          // by the parents
          newSelectors = [[]];
  
          for (i = 0; i < selector.elements.length; i++) {
              el = selector.elements[i];
              // non parent reference elements just get added
              if (el.value !== "&") {
                  currentElements.push(el);
              } else {
                  // the new list of selectors to add
                  selectorsMultiplied = [];
  
                  // merge the current list of non parent selector elements
                  // on to the current list of selectors to add
                  if (currentElements.length > 0) {
                      this.mergeElementsOnToSelectors(currentElements, newSelectors);
                  }
  
                  // loop through our current selectors
                  for(j = 0; j < newSelectors.length; j++) {
                      sel = newSelectors[j];
                      // if we don't have any parent paths, the & might be in a mixin so that it can be used
                      // whether there are parents or not
                      if (context.length == 0) {
                          // the combinator used on el should now be applied to the next element instead so that
                          // it is not lost
                          if (sel.length > 0) {
                              sel[0].elements = sel[0].elements.slice(0);
                              sel[0].elements.push(new(tree.Element)(el.combinator, '', 0)); //new Element(el.Combinator,  ""));
                          }
                          selectorsMultiplied.push(sel);
                      }
                      else {
                          // and the parent selectors
                          for(k = 0; k < context.length; k++) {
                              parentSel = context[k];
                              // We need to put the current selectors
                              // then join the last selector's elements on to the parents selectors
  
                              // our new selector path
                              newSelectorPath = [];
                              // selectors from the parent after the join
                              afterParentJoin = [];
                              newJoinedSelectorEmpty = true;
  
                              //construct the joined selector - if & is the first thing this will be empty,
                              // if not newJoinedSelector will be the last set of elements in the selector
                              if (sel.length > 0) {
                                  newSelectorPath = sel.slice(0);
                                  lastSelector = newSelectorPath.pop();
                                  newJoinedSelector = new(tree.Selector)(lastSelector.elements.slice(0));
                                  newJoinedSelectorEmpty = false;
                              }
                              else {
                                  newJoinedSelector = new(tree.Selector)([]);
                              }
  
                              //put together the parent selectors after the join
                              if (parentSel.length > 1) {
                                  afterParentJoin = afterParentJoin.concat(parentSel.slice(1));
                              }
  
                              if (parentSel.length > 0) {
                                  newJoinedSelectorEmpty = false;
  
                                  // join the elements so far with the first part of the parent
                                  newJoinedSelector.elements.push(new(tree.Element)(el.combinator, parentSel[0].elements[0].value, 0));
                                  newJoinedSelector.elements = newJoinedSelector.elements.concat(parentSel[0].elements.slice(1));
                              }
  
                              if (!newJoinedSelectorEmpty) {
                                  // now add the joined selector
                                  newSelectorPath.push(newJoinedSelector);
                              }
  
                              // and the rest of the parent
                              newSelectorPath = newSelectorPath.concat(afterParentJoin);
  
                              // add that to our new set of selectors
                              selectorsMultiplied.push(newSelectorPath);
                          }
                      }
                  }
  
                  // our new selectors has been multiplied, so reset the state
                  newSelectors = selectorsMultiplied;
                  currentElements = [];
              }
          }
  
          // if we have any elements left over (e.g. .a& .b == .b)
          // add them on to all the current selectors
          if (currentElements.length > 0) {
              this.mergeElementsOnToSelectors(currentElements, newSelectors);
          }
  
          for(i = 0; i < newSelectors.length; i++) {
              paths.push(newSelectors[i]);
          }
      },
      
      mergeElementsOnToSelectors: function(elements, selectors) {
          var i, sel;
  
          if (selectors.length == 0) {
              selectors.push([ new(tree.Selector)(elements) ]);
              return;
          }
  
          for(i = 0; i < selectors.length; i++) {
              sel = selectors[i];
  
              // if the previous thing in sel is a parent this needs to join on to it
              if (sel.length > 0) {
                  sel[sel.length - 1] = new(tree.Selector)(sel[sel.length - 1].elements.concat(elements));
              }
              else {
                  sel.push(new(tree.Selector)(elements));
              }
          }
      }
  };
  })(require('../tree'));
  (function (tree) {
  
  tree.Selector = function (elements) {
      this.elements = elements;
  };
  tree.Selector.prototype.match = function (other) {
      var elements = this.elements,
          len = elements.length,
          oelements, olen, max, i;
  
      oelements = other.elements.slice(
          (other.elements.length && other.elements[0].value === "&") ? 1 : 0);
      olen = oelements.length;
      max = Math.min(len, olen)
  
      if (olen === 0 || len < olen) {
          return false;
      } else {
          for (i = 0; i < max; i++) {
              if (elements[i].value !== oelements[i].value) {
                  return false;
              }
          }
      }
      return true;
  };
  tree.Selector.prototype.eval = function (env) {
      return new(tree.Selector)(this.elements.map(function (e) {
          return e.eval(env);
      }));
  };
  tree.Selector.prototype.toCSS = function (env) {
      if (this._css) { return this._css }
      
      if (this.elements[0].combinator.value === "") {
          this._css = ' ';
      } else {
          this._css = '';
      }
      
      this._css += this.elements.map(function (e) {
          if (typeof(e) === 'string') {
              return ' ' + e.trim();
          } else {
              return e.toCSS(env);
          }
      }).join('');
      
      return this._css;
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.UnicodeDescriptor = function (value) {
      this.value = value;
  };
  tree.UnicodeDescriptor.prototype = {
      toCSS: function (env) {
          return this.value;
      },
      eval: function () { return this }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.URL = function (val, rootpath) {
      this.value = val;
      this.rootpath = rootpath;
  };
  tree.URL.prototype = {
      toCSS: function () {
          return "url(" + this.value.toCSS() + ")";
      },
      eval: function (ctx) {
          var val = this.value.eval(ctx), rootpath;
  
          // Add the base path if the URL is relative
          if (typeof val.value === "string" && !/^(?:[a-z-]+:|\/)/.test(val.value)) {
              rootpath = this.rootpath;
              if (!val.quote) {
                  rootpath = rootpath.replace(/[\(\)'"\s]/g, function(match) { return "\\"+match; });
              }
              val.value = rootpath + val.value;
          }
  
          return new(tree.URL)(val, this.rootpath);
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Value = function (value) {
      this.value = value;
      this.is = 'value';
  };
  tree.Value.prototype = {
      eval: function (env) {
          if (this.value.length === 1) {
              return this.value[0].eval(env);
          } else {
              return new(tree.Value)(this.value.map(function (v) {
                  return v.eval(env);
              }));
          }
      },
      toCSS: function (env) {
          return this.value.map(function (e) {
              return e.toCSS(env);
          }).join(env.compress ? ',' : ', ');
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.Variable = function (name, index, file) { this.name = name, this.index = index, this.file = file };
  tree.Variable.prototype = {
      eval: function (env) {
          var variable, v, name = this.name;
  
          if (name.indexOf('@@') == 0) {
              name = '@' + new(tree.Variable)(name.slice(1)).eval(env).value;
          }
          
          if (this.evaluating) {
              throw { type: 'Name',
                      message: "Recursive variable definition for " + name,
                      filename: this.file,
                      index: this.index };
          }
          
          this.evaluating = true;
  
          if (variable = tree.find(env.frames, function (frame) {
              if (v = frame.variable(name)) {
                  return v.value.eval(env);
              }
          })) { 
              this.evaluating = false;
              return variable;
          }
          else {
              throw { type: 'Name',
                      message: "variable " + name + " is undefined",
                      filename: this.file,
                      index: this.index };
          }
      }
  };
  
  })(require('../tree'));
  (function (tree) {
  
  tree.debugInfo = function(env, ctx) {
      var result="";
      if (env.dumpLineNumbers && !env.compress) {
          switch(env.dumpLineNumbers) {
              case 'comments':
                  result = tree.debugInfo.asComment(ctx);
                  break;
              case 'mediaquery':
                  result = tree.debugInfo.asMediaQuery(ctx);
                  break;
              case 'all':
                  result = tree.debugInfo.asComment(ctx)+tree.debugInfo.asMediaQuery(ctx);
                  break;
          }
      }
      return result;
  };
  
  tree.debugInfo.asComment = function(ctx) {
      return '/* line ' + ctx.debugInfo.lineNumber + ', ' + ctx.debugInfo.fileName + ' */\n';
  };
  
  tree.debugInfo.asMediaQuery = function(ctx) {
      return '@media -sass-debug-info{filename{font-family:' +
          ('file://' + ctx.debugInfo.fileName).replace(/[\/:.]/g, '\\$&') +
          '}line{font-family:\\00003' + ctx.debugInfo.lineNumber + '}}\n';
  };
  
  tree.find = function (obj, fun) {
      for (var i = 0, r; i < obj.length; i++) {
          if (r = fun.call(obj, obj[i])) { return r }
      }
      return null;
  };
  tree.jsify = function (obj) {
      if (Array.isArray(obj.value) && (obj.value.length > 1)) {
          return '[' + obj.value.map(function (v) { return v.toCSS(false) }).join(', ') + ']';
      } else {
          return obj.toCSS(false);
      }
  };
  
  })(require('./tree'));
  //
  // browser.js - client-side engine
  //
  
  var isFileProtocol = /^(file|chrome(-extension)?|resource|qrc|app):/.test(location.protocol);
  
  less.env = less.env || (location.hostname == '127.0.0.1' ||
                          location.hostname == '0.0.0.0'   ||
                          location.hostname == 'localhost' ||
                          location.port.length > 0         ||
                          isFileProtocol                   ? 'development'
                                                           : 'production');
  
  // Load styles asynchronously (default: false)
  //
  // This is set to `false` by default, so that the body
  // doesn't start loading before the stylesheets are parsed.
  // Setting this to `true` can result in flickering.
  //
  less.async = less.async || false;
  less.fileAsync = less.fileAsync || false;
  
  // Interval between watch polls
  less.poll = less.poll || (isFileProtocol ? 1000 : 1500);
  
  //Setup user functions
  if (less.functions) {
      for(var func in less.functions) {
          less.tree.functions[func] = less.functions[func];
     }
  }
  
  var dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(location.hash);
  if (dumpLineNumbers) {
      less.dumpLineNumbers = dumpLineNumbers[1];
  }
  
  //
  // Watch mode
  //
  less.watch   = function () {	
  	if (!less.watchMode ){		
  		less.env = 'development';
  		initRunningMode();
  	}
  	return this.watchMode = true 
  };
  
  less.unwatch = function () {clearInterval(less.watchTimer); return this.watchMode = false; };
  
  function initRunningMode(){
  	if (less.env === 'development') {		
  		less.optimization = 0;		
  		less.watchTimer = setInterval(function () {			
  			if (less.watchMode) {
  				loadStyleSheets(function (e, root, _, sheet, env) {
  					if (root) {
  						createCSS(root.toCSS(), sheet, env.lastModified);
  					}
  				});
  			}
  		}, less.poll);
  	} else {
  		less.optimization = 3;
  	}
  }
  
  if (/!watch/.test(location.hash)) {
  	less.watch();
  }
  
  var cache = null;
  
  if (less.env != 'development') {
      try {
          cache = (typeof(window.localStorage) === 'undefined') ? null : window.localStorage;
      } catch (_) {}
  }
  
  //
  // Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
  //
  var links = document.getElementsByTagName('link');
  var typePattern = /^text\/(x-)?less$/;
  
  less.sheets = [];
  
  for (var i = 0; i < links.length; i++) {
      if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
         (links[i].type.match(typePattern)))) {
          less.sheets.push(links[i]);
      }
  }
  
  //
  // With this function, it's possible to alter variables and re-render
  // CSS without reloading less-files
  //
  var session_cache = '';
  less.modifyVars = function(record) {
  	var str = session_cache;
      for (name in record) {
          str += ((name.slice(0,1) === '@')? '' : '@') + name +': '+ 
                  ((record[name].slice(-1) === ';')? record[name] : record[name] +';');
      }
      new(less.Parser)().parse(str, function (e, root) {
          createCSS(root.toCSS(), less.sheets[less.sheets.length - 1]);
      });
  };
  
  less.refresh = function (reload) {
      var startTime, endTime;
      startTime = endTime = new(Date);
  
      loadStyleSheets(function (e, root, _, sheet, env) {
          if (env.local) {
              log("loading " + sheet.href + " from cache.");
          } else {
              log("parsed " + sheet.href + " successfully.");
              createCSS(root.toCSS(), sheet, env.lastModified);
          }
          log("css for " + sheet.href + " generated in " + (new(Date) - endTime) + 'ms');
          (env.remaining === 0) && log("css generated in " + (new(Date) - startTime) + 'ms');
          endTime = new(Date);
      }, reload);
  
      loadStyles();
  };
  less.refreshStyles = loadStyles;
  
  less.refresh(less.env === 'development');
  
  function loadStyles() {
      var styles = document.getElementsByTagName('style');
      for (var i = 0; i < styles.length; i++) {
          if (styles[i].type.match(typePattern)) {
              new(less.Parser)({
                  filename: document.location.href.replace(/#.*$/, ''),
                  dumpLineNumbers: less.dumpLineNumbers
              }).parse(styles[i].innerHTML || '', function (e, tree) {
                  var css = tree.toCSS();
                  var style = styles[i];
                  style.type = 'text/css';
                  if (style.styleSheet) {
                      style.styleSheet.cssText = css;
                  } else {
                      style.innerHTML = css;
                  }
              });
          }
      }
  }
  
  function loadStyleSheets(callback, reload) {
      for (var i = 0; i < less.sheets.length; i++) {
          loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1));
      }
  }
  
  function pathDiff(url, baseUrl) {
      // diff between two paths to create a relative path
  
      var urlParts = extractUrlParts(url),
          baseUrlParts = extractUrlParts(baseUrl),
          i, max, urlDirectories, baseUrlDirectories, diff = "";
      if (urlParts.hostPart !== baseUrlParts.hostPart) {
          return "";
      }
      max = Math.max(baseUrlParts.directories.length, urlParts.directories.length);
      for(i = 0; i < max; i++) {
          if (baseUrlParts.directories[i] !== urlParts.directories[i]) { break; }
      }
      baseUrlDirectories = baseUrlParts.directories.slice(i);
      urlDirectories = urlParts.directories.slice(i);
      for(i = 0; i < baseUrlDirectories.length-1; i++) {
          diff += "../";
      }
      for(i = 0; i < urlDirectories.length-1; i++) {
          diff += urlDirectories[i] + "/";
      }
      return diff;
  }
  
  function extractUrlParts(url, baseUrl) {
      // urlParts[1] = protocol&hostname || /
      // urlParts[2] = / if path relative to host base
      // urlParts[3] = directories
      // urlParts[4] = filename
      // urlParts[5] = parameters
  
      var urlPartsRegex = /^((?:[a-z-]+:)?\/\/(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/,
          urlParts = url.match(urlPartsRegex),
          returner = {}, directories = [], i, baseUrlParts;
  
      if (!urlParts) {
          throw new Error("Could not parse sheet href - '"+url+"'");
      }
  
      // Stylesheets in IE don't always return the full path    
      if (!urlParts[1] || urlParts[2]) {
          baseUrlParts = baseUrl.match(urlPartsRegex);
          if (!baseUrlParts) {
              throw new Error("Could not parse page url - '"+baseUrl+"'");
          }
          urlParts[1] = baseUrlParts[1];
          if (!urlParts[2]) {
              urlParts[3] = baseUrlParts[3] + urlParts[3];
          }
      }
      
      if (urlParts[3]) {
          directories = urlParts[3].replace("\\", "/").split("/");
  
          for(i = 0; i < directories.length; i++) {
              if (directories[i] === ".." && i > 0) {
                  directories.splice(i-1, 2);
                  i -= 2;
              }
          }
      }
  
      returner.hostPart = urlParts[1];
      returner.directories = directories;
      returner.path = urlParts[1] + directories.join("/");
      returner.fileUrl = returner.path + (urlParts[4] || "");
      returner.url = returner.fileUrl + (urlParts[5] || "");
      return returner;
  }
  
  function loadStyleSheet(sheet, callback, reload, remaining) {
      // sheet may be set to the stylesheet for the initial load or a collection of properties including
      // some env variables for imports
      var contents  = sheet.contents || {};
      var files     = sheet.files || {};
      var hrefParts = extractUrlParts(sheet.href, window.location.href);
      var href      = hrefParts.url;
      var css       = cache && cache.getItem(href);
      var timestamp = cache && cache.getItem(href + ':timestamp');
      var styles    = { css: css, timestamp: timestamp };
      var rootpath;
  
      if (less.relativeUrls) {
          if (less.rootpath) {
              if (sheet.entryPath) {
                  rootpath = extractUrlParts(less.rootpath + pathDiff(hrefParts.path, sheet.entryPath)).path;
              } else {
                  rootpath = less.rootpath;
              }
          } else {
              rootpath = hrefParts.path;
          }
      } else  {
          if (less.rootpath) {
              rootpath = less.rootpath;
          } else {
              if (sheet.entryPath) {
                  rootpath = sheet.entryPath;
              } else {
                  rootpath = hrefParts.path;
              }
          }
      }
  
      xhr(href, sheet.type, function (data, lastModified) {
          // Store data this session
          session_cache += data.replace(/@import .+?;/ig, '');
  
          if (!reload && styles && lastModified &&
             (new(Date)(lastModified).valueOf() ===
              new(Date)(styles.timestamp).valueOf())) {
              // Use local copy
              createCSS(styles.css, sheet);
              callback(null, null, data, sheet, { local: true, remaining: remaining }, href);
          } else {
              // Use remote copy (re-parse)
              try {
                  contents[href] = data;  // Updating top importing parser content cache
                  new(less.Parser)({
                      optimization: less.optimization,
                      paths: [hrefParts.path],
                      entryPath: sheet.entryPath || hrefParts.path,
                      mime: sheet.type,
                      filename: href,
                      rootpath: rootpath,
                      relativeUrls: sheet.relativeUrls,
                      contents: contents,    // Passing top importing parser content cache ref down.
                      files: files,
                      dumpLineNumbers: less.dumpLineNumbers
                  }).parse(data, function (e, root) {
                      if (e) { return error(e, href) }
                      try {
                          callback(e, root, data, sheet, { local: false, lastModified: lastModified, remaining: remaining }, href);
                          removeNode(document.getElementById('less-error-message:' + extractId(href)));
                      } catch (e) {
                          error(e, href);
                      }
                  });
              } catch (e) {
                  error(e, href);
              }
          }
      }, function (status, url) {
          throw new(Error)("Couldn't load " + url + " (" + status + ")");
      });
  }
  
  function extractId(href) {
      return href.replace(/^[a-z]+:\/\/?[^\/]+/, '' )  // Remove protocol & domain
                 .replace(/^\//,                 '' )  // Remove root /
                 .replace(/\.[a-zA-Z]+$/,        '' )  // Remove simple extension
                 .replace(/[^\.\w-]+/g,          '-')  // Replace illegal characters
                 .replace(/\./g,                 ':'); // Replace dots with colons(for valid id)
  }
  
  function createCSS(styles, sheet, lastModified) {
      var css;
  
      // Strip the query-string
      var href = sheet.href || '';
  
      // If there is no title set, use the filename, minus the extension
      var id = 'less:' + (sheet.title || extractId(href));
  
      // If the stylesheet doesn't exist, create a new node
      if ((css = document.getElementById(id)) === null) {
          css = document.createElement('style');
          css.type = 'text/css';
          if( sheet.media ){ css.media = sheet.media; }
          css.id = id;
          var nextEl = sheet && sheet.nextSibling || null;
          (nextEl || document.getElementsByTagName('head')[0]).parentNode.insertBefore(css, nextEl);
      }
  
      if (css.styleSheet) { // IE
          try {
              css.styleSheet.cssText = styles;
          } catch (e) {
              throw new(Error)("Couldn't reassign styleSheet.cssText.");
          }
      } else {
          (function (node) {
              if (css.childNodes.length > 0) {
                  if (css.firstChild.nodeValue !== node.nodeValue) {
                      css.replaceChild(node, css.firstChild);
                  }
              } else {
                  css.appendChild(node);
              }
          })(document.createTextNode(styles));
      }
  
      // Don't update the local store if the file wasn't modified
      if (lastModified && cache) {
          log('saving ' + href + ' to cache.');
          try {
              cache.setItem(href, styles);
              cache.setItem(href + ':timestamp', lastModified);
          } catch(e) {
              //TODO - could do with adding more robust error handling
              log('failed to save');
          }
      }
  }
  
  function xhr(url, type, callback, errback) {
      var xhr = getXMLHttpRequest();
      var async = isFileProtocol ? less.fileAsync : less.async;
  
      if (typeof(xhr.overrideMimeType) === 'function') {
          xhr.overrideMimeType('text/css');
      }
      xhr.open('GET', url, async);
      xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
      xhr.send(null);
  
      if (isFileProtocol && !less.fileAsync) {
          if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
              callback(xhr.responseText);
          } else {
              errback(xhr.status, url);
          }
      } else if (async) {
          xhr.onreadystatechange = function () {
              if (xhr.readyState == 4) {
                  handleResponse(xhr, callback, errback);
              }
          };
      } else {
          handleResponse(xhr, callback, errback);
      }
  
      function handleResponse(xhr, callback, errback) {
          if (xhr.status >= 200 && xhr.status < 300) {
              callback(xhr.responseText,
                       xhr.getResponseHeader("Last-Modified"));
          } else if (typeof(errback) === 'function') {
              errback(xhr.status, url);
          }
      }
  }
  
  function getXMLHttpRequest() {
      if (window.XMLHttpRequest) {
          return new(XMLHttpRequest);
      } else {
          try {
              return new(ActiveXObject)("MSXML2.XMLHTTP.3.0");
          } catch (e) {
              log("browser doesn't support AJAX.");
              return null;
          }
      }
  }
  
  function removeNode(node) {
      return node && node.parentNode.removeChild(node);
  }
  
  function log(str) {
      if (less.env == 'development' && typeof(console) !== "undefined") { console.log('less: ' + str) }
  }
  
  function error(e, href) {
      var id = 'less-error-message:' + extractId(href);
      var template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
      var elem = document.createElement('div'), timer, content, error = [];
      var filename = e.filename || href;
      var filenameNoPath = filename.match(/([^\/]+(\?.*)?)$/)[1];
  
      elem.id        = id;
      elem.className = "less-error-message";
  
      content = '<h3>'  + (e.message || 'There is an error in your .less file') +
                '</h3>' + '<p>in <a href="' + filename   + '">' + filenameNoPath + "</a> ";
  
      var errorline = function (e, i, classname) {
          if (e.extract[i]) {
              error.push(template.replace(/\{line\}/, parseInt(e.line) + (i - 1))
                                 .replace(/\{class\}/, classname)
                                 .replace(/\{content\}/, e.extract[i]));
          }
      };
  
      if (e.stack) {
          content += '<br/>' + e.stack.split('\n').slice(1).join('<br/>');
      } else if (e.extract) {
          errorline(e, 0, '');
          errorline(e, 1, 'line');
          errorline(e, 2, '');
          content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':</p>' +
                      '<ul>' + error.join('') + '</ul>';
      }
      elem.innerHTML = content;
  
      // CSS for error messages
      createCSS([
          '.less-error-message ul, .less-error-message li {',
              'list-style-type: none;',
              'margin-right: 15px;',
              'padding: 4px 0;',
              'margin: 0;',
          '}',
          '.less-error-message label {',
              'font-size: 12px;',
              'margin-right: 15px;',
              'padding: 4px 0;',
              'color: #cc7777;',
          '}',
          '.less-error-message pre {',
              'color: #dd6666;',
              'padding: 4px 0;',
              'margin: 0;',
              'display: inline-block;',
          '}',
          '.less-error-message pre.line {',
              'color: #ff0000;',
          '}',
          '.less-error-message h3 {',
              'font-size: 20px;',
              'font-weight: bold;',
              'padding: 15px 0 5px 0;',
              'margin: 0;',
          '}',
          '.less-error-message a {',
              'color: #10a',
          '}',
          '.less-error-message .error {',
              'color: red;',
              'font-weight: bold;',
              'padding-bottom: 2px;',
              'border-bottom: 1px dashed red;',
          '}'
      ].join('\n'), { title: 'error-message' });
  
      elem.style.cssText = [
          "font-family: Arial, sans-serif",
          "border: 1px solid #e00",
          "background-color: #eee",
          "border-radius: 5px",
          "-webkit-border-radius: 5px",
          "-moz-border-radius: 5px",
          "color: #e00",
          "padding: 15px",
          "margin-bottom: 15px"
      ].join(';');
  
      if (less.env == 'development') {
          timer = setInterval(function () {
              if (document.body) {
                  if (document.getElementById(id)) {
                      document.body.replaceChild(elem, document.getElementById(id));
                  } else {
                      document.body.insertBefore(elem, document.body.firstChild);
                  }
                  clearInterval(timer);
              }
          }, 10);
      }
  }
  // amd.js
  //
  // Define Less as an AMD module.
  if (typeof define === "function" && define.amd) {
      define("less", [], function () { return less; } );
  }
  })(window);
  
  
  /* **********************************************
       Begin prefixfree.js
  ********************************************** */
  
  /**
   * StyleFix 1.0.3 & PrefixFree 1.0.7
   * @author Lea Verou
   * MIT license
   */
  
  (function(){
  
  if(!window.addEventListener) {
  	return;
  }
  
  var self = window.StyleFix = {
  	link: function(link) {
  		try {
  			// Ignore stylesheets with data-noprefix attribute as well as alternate stylesheets
  			if(link.rel !== 'stylesheet' || link.hasAttribute('data-noprefix')) {
  				return;
  			}
  		}
  		catch(e) {
  			return;
  		}
  
  		var url = link.href || link.getAttribute('data-href'),
  		    base = url.replace(/[^\/]+$/, ''),
  		    base_scheme = (/^[a-z]{3,10}:/.exec(base) || [''])[0],
  		    base_domain = (/^[a-z]{3,10}:\/\/[^\/]+/.exec(base) || [''])[0],
  		    base_query = /^([^?]*)\??/.exec(url)[1],
  		    parent = link.parentNode,
  		    xhr = new XMLHttpRequest(),
  		    process;
  		
  		xhr.onreadystatechange = function() {
  			if(xhr.readyState === 4) {
  				process();
  			}
  		};
  
  		process = function() {
  				var css = xhr.responseText;
  				
  				if(css && link.parentNode && (!xhr.status || xhr.status < 400 || xhr.status > 600)) {
  					css = self.fix(css, true, link);
  					
  					// Convert relative URLs to absolute, if needed
  					if(base) {
  						css = css.replace(/url\(\s*?((?:"|')?)(.+?)\1\s*?\)/gi, function($0, quote, url) {
  							if(/^([a-z]{3,10}:|#)/i.test(url)) { // Absolute & or hash-relative
  								return $0;
  							}
  							else if(/^\/\//.test(url)) { // Scheme-relative
  								// May contain sequences like /../ and /./ but those DO work
  								return 'url("' + base_scheme + url + '")';
  							}
  							else if(/^\//.test(url)) { // Domain-relative
  								return 'url("' + base_domain + url + '")';
  							}
  							else if(/^\?/.test(url)) { // Query-relative
  								return 'url("' + base_query + url + '")';
  							}
  							else {
  								// Path-relative
  								return 'url("' + base + url + '")';
  							}
  						});
  
  						// behavior URLs shoudn’t be converted (Issue #19)
  						// base should be escaped before added to RegExp (Issue #81)
  						var escaped_base = base.replace(/([\\\^\$*+[\]?{}.=!:(|)])/g,"\\$1");
  						css = css.replace(RegExp('\\b(behavior:\\s*?url\\(\'?"?)' + escaped_base, 'gi'), '$1');
  						}
  					
  					var style = document.createElement('style');
  					style.textContent = css;
  					style.media = link.media;
  					style.disabled = link.disabled;
  					style.setAttribute('data-href', link.getAttribute('href'));
  					
  					parent.insertBefore(style, link);
  					parent.removeChild(link);
  					
  					style.media = link.media; // Duplicate is intentional. See issue #31
  				}
  		};
  
  		try {
  			xhr.open('GET', url);
  			xhr.send(null);
  		} catch (e) {
  			// Fallback to XDomainRequest if available
  			if (typeof XDomainRequest != "undefined") {
  				xhr = new XDomainRequest();
  				xhr.onerror = xhr.onprogress = function() {};
  				xhr.onload = process;
  				xhr.open("GET", url);
  				xhr.send(null);
  			}
  		}
  		
  		link.setAttribute('data-inprogress', '');
  	},
  
  	styleElement: function(style) {
  		if (style.hasAttribute('data-noprefix')) {
  			return;
  		}
  		var disabled = style.disabled;
  		
  		style.textContent = self.fix(style.textContent, true, style);
  		
  		style.disabled = disabled;
  	},
  
  	styleAttribute: function(element) {
  		var css = element.getAttribute('style');
  		
  		css = self.fix(css, false, element);
  		
  		element.setAttribute('style', css);
  	},
  	
  	process: function() {
  		// Linked stylesheets
  		$('link[rel="stylesheet"]:not([data-inprogress])').forEach(StyleFix.link);
  		
  		// Inline stylesheets
  		$('style').forEach(StyleFix.styleElement);
  		
  		// Inline styles
  		$('[style]').forEach(StyleFix.styleAttribute);
  	},
  	
  	register: function(fixer, index) {
  		(self.fixers = self.fixers || [])
  			.splice(index === undefined? self.fixers.length : index, 0, fixer);
  	},
  	
  	fix: function(css, raw, element) {
  		for(var i=0; i<self.fixers.length; i++) {
  			css = self.fixers[i](css, raw, element) || css;
  		}
  		
  		return css;
  	},
  	
  	camelCase: function(str) {
  		return str.replace(/-([a-z])/g, function($0, $1) { return $1.toUpperCase(); }).replace('-','');
  	},
  	
  	deCamelCase: function(str) {
  		return str.replace(/[A-Z]/g, function($0) { return '-' + $0.toLowerCase() });
  	}
  };
  
  /**************************************
   * Process styles
   **************************************/
  (function(){
  	setTimeout(function(){
  		$('link[rel="stylesheet"]').forEach(StyleFix.link);
  	}, 10);
  	
  	document.addEventListener('DOMContentLoaded', StyleFix.process, false);
  })();
  
  function $(expr, con) {
  	return [].slice.call((con || document).querySelectorAll(expr));
  }
  
  })();
  
  /**
   * PrefixFree
   */
  (function(root){
  
  if(!window.StyleFix || !window.getComputedStyle) {
  	return;
  }
  
  // Private helper
  function fix(what, before, after, replacement, css) {
  	what = self[what];
  	
  	if(what.length) {
  		var regex = RegExp(before + '(' + what.join('|') + ')' + after, 'gi');
  
  		css = css.replace(regex, replacement);
  	}
  	
  	return css;
  }
  
  var self = window.PrefixFree = {
  	prefixCSS: function(css, raw, element) {
  		var prefix = self.prefix;
  		
  		// Gradient angles hotfix
  		if(self.functions.indexOf('linear-gradient') > -1) {
  			// Gradients are supported with a prefix, convert angles to legacy
  			css = css.replace(/(\s|:|,)(repeating-)?linear-gradient\(\s*(-?\d*\.?\d*)deg/ig, function ($0, delim, repeating, deg) {
  				return delim + (repeating || '') + 'linear-gradient(' + (90-deg) + 'deg';
  			});
  		}
  		
  		css = fix('functions', '(\\s|:|,)', '\\s*\\(', '$1' + prefix + '$2(', css);
  		css = fix('keywords', '(\\s|:)', '(\\s|;|\\}|$)', '$1' + prefix + '$2$3', css);
  		css = fix('properties', '(^|\\{|\\s|;)', '\\s*:', '$1' + prefix + '$2:', css);
  		
  		// Prefix properties *inside* values (issue #8)
  		if (self.properties.length) {
  			var regex = RegExp('\\b(' + self.properties.join('|') + ')(?!:)', 'gi');
  			
  			css = fix('valueProperties', '\\b', ':(.+?);', function($0) {
  				return $0.replace(regex, prefix + "$1")
  			}, css);
  		}
  		
  		if(raw) {
  			css = fix('selectors', '', '\\b', self.prefixSelector, css);
  			css = fix('atrules', '@', '\\b', '@' + prefix + '$1', css);
  		}
  		
  		// Fix double prefixing
  		css = css.replace(RegExp('-' + prefix, 'g'), '-');
  		
  		// Prefix wildcard
  		css = css.replace(/-\*-(?=[a-z]+)/gi, self.prefix);
  		
  		return css;
  	},
  	
  	property: function(property) {
  		return (self.properties.indexOf(property)? self.prefix : '') + property;
  	},
  	
  	value: function(value, property) {
  		value = fix('functions', '(^|\\s|,)', '\\s*\\(', '$1' + self.prefix + '$2(', value);
  		value = fix('keywords', '(^|\\s)', '(\\s|$)', '$1' + self.prefix + '$2$3', value);
  		
  		// TODO properties inside values
  		
  		return value;
  	},
  	
  	// Warning: Prefixes no matter what, even if the selector is supported prefix-less
  	prefixSelector: function(selector) {
  		return selector.replace(/^:{1,2}/, function($0) { return $0 + self.prefix })
  	},
  	
  	// Warning: Prefixes no matter what, even if the property is supported prefix-less
  	prefixProperty: function(property, camelCase) {
  		var prefixed = self.prefix + property;
  		
  		return camelCase? StyleFix.camelCase(prefixed) : prefixed;
  	}
  };
  
  /**************************************
   * Properties
   **************************************/
  (function() {
  	var prefixes = {},
  		properties = [],
  		shorthands = {},
  		style = getComputedStyle(document.documentElement, null),
  		dummy = document.createElement('div').style;
  	
  	// Why are we doing this instead of iterating over properties in a .style object? Cause Webkit won't iterate over those.
  	var iterate = function(property) {
  		if(property.charAt(0) === '-') {
  			properties.push(property);
  			
  			var parts = property.split('-'),
  				prefix = parts[1];
  				
  			// Count prefix uses
  			prefixes[prefix] = ++prefixes[prefix] || 1;
  			
  			// This helps determining shorthands
  			while(parts.length > 3) {
  				parts.pop();
  				
  				var shorthand = parts.join('-');
  
  				if(supported(shorthand) && properties.indexOf(shorthand) === -1) {
  					properties.push(shorthand);
  				}
  			}
  		}
  	},
  	supported = function(property) {
  		return StyleFix.camelCase(property) in dummy;
  	}
  	
  	// Some browsers have numerical indices for the properties, some don't
  	if(style.length > 0) {
  		for(var i=0; i<style.length; i++) {
  			iterate(style[i])
  		}
  	}
  	else {
  		for(var property in style) {
  			iterate(StyleFix.deCamelCase(property));
  		}
  	}
  
  	// Find most frequently used prefix
  	var highest = {uses:0};
  	for(var prefix in prefixes) {
  		var uses = prefixes[prefix];
  
  		if(highest.uses < uses) {
  			highest = {prefix: prefix, uses: uses};
  		}
  	}
  	
  	self.prefix = '-' + highest.prefix + '-';
  	self.Prefix = StyleFix.camelCase(self.prefix);
  	
  	self.properties = [];
  
  	// Get properties ONLY supported with a prefix
  	for(var i=0; i<properties.length; i++) {
  		var property = properties[i];
  		
  		if(property.indexOf(self.prefix) === 0) { // we might have multiple prefixes, like Opera
  			var unprefixed = property.slice(self.prefix.length);
  			
  			if(!supported(unprefixed)) {
  				self.properties.push(unprefixed);
  			}
  		}
  	}
  	
  	// IE fix
  	if(self.Prefix == 'Ms' 
  	  && !('transform' in dummy) 
  	  && !('MsTransform' in dummy) 
  	  && ('msTransform' in dummy)) {
  		self.properties.push('transform', 'transform-origin');	
  	}
  	
  	self.properties.sort();
  })();
  
  /**************************************
   * Values
   **************************************/
  (function() {
  // Values that might need prefixing
  var functions = {
  	'linear-gradient': {
  		property: 'backgroundImage',
  		params: 'red, teal'
  	},
  	'calc': {
  		property: 'width',
  		params: '1px + 5%'
  	},
  	'element': {
  		property: 'backgroundImage',
  		params: '#foo'
  	},
  	'cross-fade': {
  		property: 'backgroundImage',
  		params: 'url(a.png), url(b.png), 50%'
  	}
  };
  
  
  functions['repeating-linear-gradient'] =
  functions['repeating-radial-gradient'] =
  functions['radial-gradient'] =
  functions['linear-gradient'];
  
  // Note: The properties assigned are just to *test* support. 
  // The keywords will be prefixed everywhere.
  var keywords = {
  	'initial': 'color',
  	'zoom-in': 'cursor',
  	'zoom-out': 'cursor',
  	'box': 'display',
  	'flexbox': 'display',
  	'inline-flexbox': 'display',
  	'flex': 'display',
  	'inline-flex': 'display',
  	'grid': 'display',
  	'inline-grid': 'display',
  	'min-content': 'width'
  };
  
  self.functions = [];
  self.keywords = [];
  
  var style = document.createElement('div').style;
  
  function supported(value, property) {
  	style[property] = '';
  	style[property] = value;
  
  	return !!style[property];
  }
  
  for (var func in functions) {
  	var test = functions[func],
  		property = test.property,
  		value = func + '(' + test.params + ')';
  	
  	if (!supported(value, property)
  	  && supported(self.prefix + value, property)) {
  		// It's supported, but with a prefix
  		self.functions.push(func);
  	}
  }
  
  for (var keyword in keywords) {
  	var property = keywords[keyword];
  
  	if (!supported(keyword, property)
  	  && supported(self.prefix + keyword, property)) {
  		// It's supported, but with a prefix
  		self.keywords.push(keyword);
  	}
  }
  
  })();
  
  /**************************************
   * Selectors and @-rules
   **************************************/
  (function() {
  
  var 
  selectors = {
  	':read-only': null,
  	':read-write': null,
  	':any-link': null,
  	'::selection': null
  },
  
  atrules = {
  	'keyframes': 'name',
  	'viewport': null,
  	'document': 'regexp(".")'
  };
  
  self.selectors = [];
  self.atrules = [];
  
  var style = root.appendChild(document.createElement('style'));
  
  function supported(selector) {
  	style.textContent = selector + '{}';  // Safari 4 has issues with style.innerHTML
  	
  	return !!style.sheet.cssRules.length;
  }
  
  for(var selector in selectors) {
  	var test = selector + (selectors[selector]? '(' + selectors[selector] + ')' : '');
  		
  	if(!supported(test) && supported(self.prefixSelector(test))) {
  		self.selectors.push(selector);
  	}
  }
  
  for(var atrule in atrules) {
  	var test = atrule + ' ' + (atrules[atrule] || '');
  	
  	if(!supported('@' + test) && supported('@' + self.prefix + test)) {
  		self.atrules.push(atrule);
  	}
  }
  
  root.removeChild(style);
  
  })();
  
  // Properties that accept properties as their value
  self.valueProperties = [
  	'transition',
  	'transition-property'
  ]
  
  // Add class for current prefix
  root.className += ' ' + self.prefix;
  
  StyleFix.register(self.prefixCSS);
  
  
  })(document.documentElement);
  
  
  /* **********************************************
       Begin modernizr.custom.js
  ********************************************** */
  
  /* Modernizr 2.6.2 (Custom Build) | MIT & BSD
   * Build: http://modernizr.com/download/#-fontface-backgroundsize-borderimage-borderradius-boxshadow-flexbox-hsla-multiplebgs-opacity-rgba-textshadow-cssanimations-csscolumns-generatedcontent-cssgradients-cssreflections-csstransforms-csstransforms3d-csstransitions-applicationcache-canvas-canvastext-draganddrop-hashchange-history-audio-video-indexeddb-input-inputtypes-localstorage-postmessage-sessionstorage-websockets-websqldatabase-webworkers-geolocation-inlinesvg-smil-svg-svgclippaths-touch-webgl-printshiv-mq-cssclasses-addtest-prefixed-teststyles-testprop-testallprops-hasevent-prefixes-domprefixes-a_download-audio_audiodata_api-audio_webaudio_api-battery_api-battery_level-blob_constructor-canvas_todataurl_type-contenteditable-contentsecuritypolicy-contextmenu-cookies-cors-css_backgroundposition_shorthand-css_backgroundposition_xy-css_backgroundrepeat-css_backgroundsizecover-css_boxsizing-css_calc-css_cubicbezierrange-css_displayrunin-css_displaytable-css_filters-css_hyphens-css_lastchild-css_mask-css_mediaqueries-css_objectfit-css_overflow_scrolling-css_pointerevents-css_positionsticky-css_remunit-css_regions-css_resize-css_scrollbars-css_subpixelfont-css_supports-css_userselect-css_vhunit-css_vmaxunit-css_vminunit-css_vwunit-custom_protocol_handler-dataview_api-dom_classlist-dom_createElement_attrs-dom_dataset-dom_microdata-elem_datalist-elem_details-elem_output-elem_progress_meter-elem_ruby-elem_time-elem_track-emoji-es5_strictmode-event_deviceorientation_motion-exif_orientation-file_api-forms_fileinput-forms_formattribute-file_filesystem-forms_placeholder-forms_speechinput-forms_validation-fullscreen_api-gamepad-getusermedia-ie8compat-iframe_sandbox-iframe_seamless-iframe_srcdoc-img_apng-img_webp-json-lists_reversed-mathml-network_connection-network_eventsource-network_xhr2-notification-performance-pointerlock_api-quota_management_api-requestanimationframe-script_async-script_defer-style_scoped-svg_filters-unicode-url_data_uri-userdata-vibration-web_intents-webgl_extensions-websockets_binary-window_framed-workers_blobworkers-workers_dataworkers-workers_sharedworkers-load
   */
  ;
  
  
  
  window.Modernizr = (function( window, document, undefined ) {
  
      var version = '2.6.2',
  
      Modernizr = {},
  
      enableClasses = true,
  
      docElement = document.documentElement,
  
      mod = 'modernizr',
      modElem = document.createElement(mod),
      mStyle = modElem.style,
  
      inputElem  = document.createElement('input')  ,
  
      smile = ':)',
  
      toString = {}.toString,
  
      prefixes = ' -webkit- -moz- -o- -ms- '.split(' '),
  
  
  
      omPrefixes = 'Webkit Moz O ms',
  
      cssomPrefixes = omPrefixes.split(' '),
  
      domPrefixes = omPrefixes.toLowerCase().split(' '),
  
      ns = {'svg': 'http://www.w3.org/2000/svg'},
  
      tests = {},
      inputs = {},
      attrs = {},
  
      classes = [],
  
      slice = classes.slice,
  
      featureName, 
  
  
      injectElementWithStyles = function( rule, callback, nodes, testnames ) {
  
        var style, ret, node, docOverflow,
            div = document.createElement('div'),
                  body = document.body,
                  fakeBody = body || document.createElement('body');
  
        if ( parseInt(nodes, 10) ) {
                        while ( nodes-- ) {
                node = document.createElement('div');
                node.id = testnames ? testnames[nodes] : mod + (nodes + 1);
                div.appendChild(node);
            }
        }
  
                  style = ['&#173;','<style id="s', mod, '">', rule, '</style>'].join('');
        div.id = mod;
            (body ? div : fakeBody).innerHTML += style;
        fakeBody.appendChild(div);
        if ( !body ) {
                  fakeBody.style.background = '';
                  fakeBody.style.overflow = 'hidden';
            docOverflow = docElement.style.overflow;
            docElement.style.overflow = 'hidden';
            docElement.appendChild(fakeBody);
        }
  
        ret = callback(div, rule);
          if ( !body ) {
            fakeBody.parentNode.removeChild(fakeBody);
            docElement.style.overflow = docOverflow;
        } else {
            div.parentNode.removeChild(div);
        }
  
        return !!ret;
  
      },
  
      testMediaQuery = function( mq ) {
  
        var matchMedia = window.matchMedia || window.msMatchMedia;
        if ( matchMedia ) {
          return matchMedia(mq).matches;
        }
  
        var bool;
  
        injectElementWithStyles('@media ' + mq + ' { #' + mod + ' { position: absolute; } }', function( node ) {
          bool = (window.getComputedStyle ?
                    getComputedStyle(node, null) :
                    node.currentStyle)['position'] == 'absolute';
        });
  
        return bool;
  
       },
   
  
      isEventSupported = (function() {
  
        var TAGNAMES = {
          'select': 'input', 'change': 'input',
          'submit': 'form', 'reset': 'form',
          'error': 'img', 'load': 'img', 'abort': 'img'
        };
  
        function isEventSupported( eventName, element ) {
  
          element = element || document.createElement(TAGNAMES[eventName] || 'div');
          eventName = 'on' + eventName;
  
              var isSupported = eventName in element;
  
          if ( !isSupported ) {
                  if ( !element.setAttribute ) {
              element = document.createElement('div');
            }
            if ( element.setAttribute && element.removeAttribute ) {
              element.setAttribute(eventName, '');
              isSupported = is(element[eventName], 'function');
  
                      if ( !is(element[eventName], 'undefined') ) {
                element[eventName] = undefined;
              }
              element.removeAttribute(eventName);
            }
          }
  
          element = null;
          return isSupported;
        }
        return isEventSupported;
      })(),
  
  
      _hasOwnProperty = ({}).hasOwnProperty, hasOwnProp;
  
      if ( !is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined') ) {
        hasOwnProp = function (object, property) {
          return _hasOwnProperty.call(object, property);
        };
      }
      else {
        hasOwnProp = function (object, property) { 
          return ((property in object) && is(object.constructor.prototype[property], 'undefined'));
        };
      }
  
  
      if (!Function.prototype.bind) {
        Function.prototype.bind = function bind(that) {
  
          var target = this;
  
          if (typeof target != "function") {
              throw new TypeError();
          }
  
          var args = slice.call(arguments, 1),
              bound = function () {
  
              if (this instanceof bound) {
  
                var F = function(){};
                F.prototype = target.prototype;
                var self = new F();
  
                var result = target.apply(
                    self,
                    args.concat(slice.call(arguments))
                );
                if (Object(result) === result) {
                    return result;
                }
                return self;
  
              } else {
  
                return target.apply(
                    that,
                    args.concat(slice.call(arguments))
                );
  
              }
  
          };
  
          return bound;
        };
      }
  
      function setCss( str ) {
          mStyle.cssText = str;
      }
  
      function setCssAll( str1, str2 ) {
          return setCss(prefixes.join(str1 + ';') + ( str2 || '' ));
      }
  
      function is( obj, type ) {
          return typeof obj === type;
      }
  
      function contains( str, substr ) {
          return !!~('' + str).indexOf(substr);
      }
  
      function testProps( props, prefixed ) {
          for ( var i in props ) {
              var prop = props[i];
              if ( !contains(prop, "-") && mStyle[prop] !== undefined ) {
                  return prefixed == 'pfx' ? prop : true;
              }
          }
          return false;
      }
  
      function testDOMProps( props, obj, elem ) {
          for ( var i in props ) {
              var item = obj[props[i]];
              if ( item !== undefined) {
  
                              if (elem === false) return props[i];
  
                              if (is(item, 'function')){
                                  return item.bind(elem || obj);
                  }
  
                              return item;
              }
          }
          return false;
      }
  
      function testPropsAll( prop, prefixed, elem ) {
  
          var ucProp  = prop.charAt(0).toUpperCase() + prop.slice(1),
              props   = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');
  
              if(is(prefixed, "string") || is(prefixed, "undefined")) {
            return testProps(props, prefixed);
  
              } else {
            props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');
            return testDOMProps(props, prefixed, elem);
          }
      }    tests['flexbox'] = function() {
        return testPropsAll('flexWrap');
      };    tests['canvas'] = function() {
          var elem = document.createElement('canvas');
          return !!(elem.getContext && elem.getContext('2d'));
      };
  
      tests['canvastext'] = function() {
          return !!(Modernizr['canvas'] && is(document.createElement('canvas').getContext('2d').fillText, 'function'));
      };
  
  
  
      tests['webgl'] = function() {
          return !!window.WebGLRenderingContext;
      };
  
  
      tests['touch'] = function() {
          var bool;
  
          if(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch) {
            bool = true;
          } else {
            injectElementWithStyles(['@media (',prefixes.join('touch-enabled),('),mod,')','{#modernizr{top:9px;position:absolute}}'].join(''), function( node ) {
              bool = node.offsetTop === 9;
            });
          }
  
          return bool;
      };
  
  
  
      tests['geolocation'] = function() {
          return 'geolocation' in navigator;
      };
  
  
      tests['postmessage'] = function() {
        return !!window.postMessage;
      };
  
  
      tests['websqldatabase'] = function() {
        return !!window.openDatabase;
      };
  
      tests['indexedDB'] = function() {
        return !!testPropsAll("indexedDB", window);
      };
  
      tests['hashchange'] = function() {
        return isEventSupported('hashchange', window) && (document.documentMode === undefined || document.documentMode > 7);
      };
  
      tests['history'] = function() {
        return !!(window.history && history.pushState);
      };
  
      tests['draganddrop'] = function() {
          var div = document.createElement('div');
          return ('draggable' in div) || ('ondragstart' in div && 'ondrop' in div);
      };
  
      tests['websockets'] = function() {
          return 'WebSocket' in window || 'MozWebSocket' in window;
      };
  
  
      tests['rgba'] = function() {
          setCss('background-color:rgba(150,255,150,.5)');
  
          return contains(mStyle.backgroundColor, 'rgba');
      };
  
      tests['hsla'] = function() {
              setCss('background-color:hsla(120,40%,100%,.5)');
  
          return contains(mStyle.backgroundColor, 'rgba') || contains(mStyle.backgroundColor, 'hsla');
      };
  
      tests['multiplebgs'] = function() {
                  setCss('background:url(https://),url(https://),red url(https://)');
  
              return (/(url\s*\(.*?){3}/).test(mStyle.background);
      };    tests['backgroundsize'] = function() {
          return testPropsAll('backgroundSize');
      };
  
      tests['borderimage'] = function() {
          return testPropsAll('borderImage');
      };
  
  
  
      tests['borderradius'] = function() {
          return testPropsAll('borderRadius');
      };
  
      tests['boxshadow'] = function() {
          return testPropsAll('boxShadow');
      };
  
      tests['textshadow'] = function() {
          return document.createElement('div').style.textShadow === '';
      };
  
  
      tests['opacity'] = function() {
                  setCssAll('opacity:.55');
  
                      return (/^0.55$/).test(mStyle.opacity);
      };
  
  
      tests['cssanimations'] = function() {
          return testPropsAll('animationName');
      };
  
  
      tests['csscolumns'] = function() {
          return testPropsAll('columnCount');
      };
  
  
      tests['cssgradients'] = function() {
          var str1 = 'background-image:',
              str2 = 'gradient(linear,left top,right bottom,from(#9f9),to(white));',
              str3 = 'linear-gradient(left top,#9f9, white);';
  
          setCss(
                         (str1 + '-webkit- '.split(' ').join(str2 + str1) +
                         prefixes.join(str3 + str1)).slice(0, -str1.length)
          );
  
          return contains(mStyle.backgroundImage, 'gradient');
      };
  
  
      tests['cssreflections'] = function() {
          return testPropsAll('boxReflect');
      };
  
  
      tests['csstransforms'] = function() {
          return !!testPropsAll('transform');
      };
  
  
      tests['csstransforms3d'] = function() {
  
          var ret = !!testPropsAll('perspective');
  
                          if ( ret && 'webkitPerspective' in docElement.style ) {
  
                        injectElementWithStyles('@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}', function( node, rule ) {
              ret = node.offsetLeft === 9 && node.offsetHeight === 3;
            });
          }
          return ret;
      };
  
  
      tests['csstransitions'] = function() {
          return testPropsAll('transition');
      };
  
  
  
      tests['fontface'] = function() {
          var bool;
  
          injectElementWithStyles('@font-face {font-family:"font";src:url("https://")}', function( node, rule ) {
            var style = document.getElementById('smodernizr'),
                sheet = style.sheet || style.styleSheet,
                cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : '';
  
            bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0;
          });
  
          return bool;
      };
  
      tests['generatedcontent'] = function() {
          var bool;
  
          injectElementWithStyles(['#',mod,'{font:0/0 a}#',mod,':after{content:"',smile,'";visibility:hidden;font:3px/1 a}'].join(''), function( node ) {
            bool = node.offsetHeight >= 3;
          });
  
          return bool;
      };
      tests['video'] = function() {
          var elem = document.createElement('video'),
              bool = false;
  
              try {
              if ( bool = !!elem.canPlayType ) {
                  bool      = new Boolean(bool);
                  bool.ogg  = elem.canPlayType('video/ogg; codecs="theora"')      .replace(/^no$/,'');
  
                              bool.h264 = elem.canPlayType('video/mp4; codecs="avc1.42E01E"') .replace(/^no$/,'');
  
                  bool.webm = elem.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/,'');
              }
  
          } catch(e) { }
  
          return bool;
      };
  
      tests['audio'] = function() {
          var elem = document.createElement('audio'),
              bool = false;
  
          try {
              if ( bool = !!elem.canPlayType ) {
                  bool      = new Boolean(bool);
                  bool.ogg  = elem.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/,'');
                  bool.mp3  = elem.canPlayType('audio/mpeg;')               .replace(/^no$/,'');
  
                                                      bool.wav  = elem.canPlayType('audio/wav; codecs="1"')     .replace(/^no$/,'');
                  bool.m4a  = ( elem.canPlayType('audio/x-m4a;')            ||
                                elem.canPlayType('audio/aac;'))             .replace(/^no$/,'');
              }
          } catch(e) { }
  
          return bool;
      };
  
  
      tests['localstorage'] = function() {
          try {
              localStorage.setItem(mod, mod);
              localStorage.removeItem(mod);
              return true;
          } catch(e) {
              return false;
          }
      };
  
      tests['sessionstorage'] = function() {
          try {
              sessionStorage.setItem(mod, mod);
              sessionStorage.removeItem(mod);
              return true;
          } catch(e) {
              return false;
          }
      };
  
  
      tests['webworkers'] = function() {
          return !!window.Worker;
      };
  
  
      tests['applicationcache'] = function() {
          return !!window.applicationCache;
      };
  
  
      tests['svg'] = function() {
          return !!document.createElementNS && !!document.createElementNS(ns.svg, 'svg').createSVGRect;
      };
  
      tests['inlinesvg'] = function() {
        var div = document.createElement('div');
        div.innerHTML = '<svg/>';
        return (div.firstChild && div.firstChild.namespaceURI) == ns.svg;
      };
  
      tests['smil'] = function() {
          return !!document.createElementNS && /SVGAnimate/.test(toString.call(document.createElementNS(ns.svg, 'animate')));
      };
  
  
      tests['svgclippaths'] = function() {
          return !!document.createElementNS && /SVGClipPath/.test(toString.call(document.createElementNS(ns.svg, 'clipPath')));
      };
  
      function webforms() {
                                              Modernizr['input'] = (function( props ) {
              for ( var i = 0, len = props.length; i < len; i++ ) {
                  attrs[ props[i] ] = !!(props[i] in inputElem);
              }
              if (attrs.list){
                                    attrs.list = !!(document.createElement('datalist') && window.HTMLDataListElement);
              }
              return attrs;
          })('autocomplete autofocus list placeholder max min multiple pattern required step'.split(' '));
                              Modernizr['inputtypes'] = (function(props) {
  
              for ( var i = 0, bool, inputElemType, defaultView, len = props.length; i < len; i++ ) {
  
                  inputElem.setAttribute('type', inputElemType = props[i]);
                  bool = inputElem.type !== 'text';
  
                                                      if ( bool ) {
  
                      inputElem.value         = smile;
                      inputElem.style.cssText = 'position:absolute;visibility:hidden;';
  
                      if ( /^range$/.test(inputElemType) && inputElem.style.WebkitAppearance !== undefined ) {
  
                        docElement.appendChild(inputElem);
                        defaultView = document.defaultView;
  
                                          bool =  defaultView.getComputedStyle &&
                                defaultView.getComputedStyle(inputElem, null).WebkitAppearance !== 'textfield' &&
                                                                                    (inputElem.offsetHeight !== 0);
  
                        docElement.removeChild(inputElem);
  
                      } else if ( /^(search|tel)$/.test(inputElemType) ){
                                                                                      } else if ( /^(url|email)$/.test(inputElemType) ) {
                                          bool = inputElem.checkValidity && inputElem.checkValidity() === false;
  
                      } else {
                                          bool = inputElem.value != smile;
                      }
                  }
  
                  inputs[ props[i] ] = !!bool;
              }
              return inputs;
          })('search tel url email datetime date month week time datetime-local number range color'.split(' '));
          }
      for ( var feature in tests ) {
          if ( hasOwnProp(tests, feature) ) {
                                      featureName  = feature.toLowerCase();
              Modernizr[featureName] = tests[feature]();
  
              classes.push((Modernizr[featureName] ? '' : 'no-') + featureName);
          }
      }
  
      Modernizr.input || webforms();
  
  
       Modernizr.addTest = function ( feature, test ) {
         if ( typeof feature == 'object' ) {
           for ( var key in feature ) {
             if ( hasOwnProp( feature, key ) ) {
               Modernizr.addTest( key, feature[ key ] );
             }
           }
         } else {
  
           feature = feature.toLowerCase();
  
           if ( Modernizr[feature] !== undefined ) {
                                                return Modernizr;
           }
  
           test = typeof test == 'function' ? test() : test;
  
           if (typeof enableClasses !== "undefined" && enableClasses) {
             docElement.className += ' ' + (test ? '' : 'no-') + feature;
           }
           Modernizr[feature] = test;
  
         }
  
         return Modernizr; 
       };
  
  
      setCss('');
      modElem = inputElem = null;
  
  
      Modernizr._version      = version;
  
      Modernizr._prefixes     = prefixes;
      Modernizr._domPrefixes  = domPrefixes;
      Modernizr._cssomPrefixes  = cssomPrefixes;
  
      Modernizr.mq            = testMediaQuery;
  
      Modernizr.hasEvent      = isEventSupported;
  
      Modernizr.testProp      = function(prop){
          return testProps([prop]);
      };
  
      Modernizr.testAllProps  = testPropsAll;
  
  
      Modernizr.testStyles    = injectElementWithStyles;
      Modernizr.prefixed      = function(prop, obj, elem){
        if(!obj) {
          return testPropsAll(prop, 'pfx');
        } else {
              return testPropsAll(prop, obj, elem);
        }
      };
  
  
      docElement.className = docElement.className.replace(/(^|\s)no-js(\s|$)/, '$1$2') +
  
                                                      (enableClasses ? ' js ' + classes.join(' ') : '');
  
      return Modernizr;
  
  })(this, this.document);
  /*! HTML5 Shiv v3.6 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed */
  ;(function(window, document) {
  /*jshint evil:true */
    /** Preset options */
    var options = window.html5 || {};
  
    /** Used to skip problem elements */
    var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
  
    /** Not all elements can be cloned in IE (this list can be shortend) **/
    var saveClones = /^<|^(?:a|b|button|code|div|fieldset|form|h1|h2|h3|h4|h5|h6|i|iframe|img|input|label|li|link|ol|option|p|param|q|script|select|span|strong|style|table|tbody|td|textarea|tfoot|th|thead|tr|ul)$/i;
  
    /** Detect whether the browser supports default html5 styles */
    var supportsHtml5Styles;
  
    /** Name of the expando, to work with multiple documents or to re-shiv one document */
    var expando = '_html5shiv';
  
    /** The id for the the documents expando */
    var expanID = 0;
  
    /** Cached data for each document */
    var expandoData = {};
  
    /** Detect whether the browser supports unknown elements */
    var supportsUnknownElements;
  
    (function() {
      try {
          var a = document.createElement('a');
          a.innerHTML = '<xyz></xyz>';
          //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
          supportsHtml5Styles = ('hidden' in a);
  
          supportsUnknownElements = a.childNodes.length == 1 || (function() {
            // assign a false positive if unable to shiv
            (document.createElement)('a');
            var frag = document.createDocumentFragment();
            return (
              typeof frag.cloneNode == 'undefined' ||
              typeof frag.createDocumentFragment == 'undefined' ||
              typeof frag.createElement == 'undefined'
            );
          }());
      } catch(e) {
        supportsHtml5Styles = true;
        supportsUnknownElements = true;
      }
  
    }());
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * Creates a style sheet with the given CSS text and adds it to the document.
     * @private
     * @param {Document} ownerDocument The document.
     * @param {String} cssText The CSS text.
     * @returns {StyleSheet} The style element.
     */
    function addStyleSheet(ownerDocument, cssText) {
      var p = ownerDocument.createElement('p'),
          parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;
  
      p.innerHTML = 'x<style>' + cssText + '</style>';
      return parent.insertBefore(p.lastChild, parent.firstChild);
    }
  
    /**
     * Returns the value of `html5.elements` as an array.
     * @private
     * @returns {Array} An array of shived element node names.
     */
    function getElements() {
      var elements = html5.elements;
      return typeof elements == 'string' ? elements.split(' ') : elements;
    }
    
      /**
     * Returns the data associated to the given document
     * @private
     * @param {Document} ownerDocument The document.
     * @returns {Object} An object of data.
     */
    function getExpandoData(ownerDocument) {
      var data = expandoData[ownerDocument[expando]];
      if (!data) {
          data = {};
          expanID++;
          ownerDocument[expando] = expanID;
          expandoData[expanID] = data;
      }
      return data;
    }
  
    /**
     * returns a shived element for the given nodeName and document
     * @memberOf html5
     * @param {String} nodeName name of the element
     * @param {Document} ownerDocument The context document.
     * @returns {Object} The shived element.
     */
    function createElement(nodeName, ownerDocument, data){
      if (!ownerDocument) {
          ownerDocument = document;
      }
      if(supportsUnknownElements){
          return ownerDocument.createElement(nodeName);
      }
      if (!data) {
          data = getExpandoData(ownerDocument);
      }
      var node;
  
      if (data.cache[nodeName]) {
          node = data.cache[nodeName].cloneNode();
      } else if (saveClones.test(nodeName)) {
          node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();
      } else {
          node = data.createElem(nodeName);
      }
  
      // Avoid adding some elements to fragments in IE < 9 because
      // * Attributes like `name` or `type` cannot be set/changed once an element
      //   is inserted into a document/fragment
      // * Link elements with `src` attributes that are inaccessible, as with
      //   a 403 response, will cause the tab/window to crash
      // * Script elements appended to fragments will execute when their `src`
      //   or `text` property is set
      return node.canHaveChildren && !reSkip.test(nodeName) ? data.frag.appendChild(node) : node;
    }
  
    /**
     * returns a shived DocumentFragment for the given document
     * @memberOf html5
     * @param {Document} ownerDocument The context document.
     * @returns {Object} The shived DocumentFragment.
     */
    function createDocumentFragment(ownerDocument, data){
      if (!ownerDocument) {
          ownerDocument = document;
      }
      if(supportsUnknownElements){
          return ownerDocument.createDocumentFragment();
      }
      data = data || getExpandoData(ownerDocument);
      var clone = data.frag.cloneNode(),
          i = 0,
          elems = getElements(),
          l = elems.length;
      for(;i<l;i++){
          clone.createElement(elems[i]);
      }
      return clone;
    }
  
    /**
     * Shivs the `createElement` and `createDocumentFragment` methods of the document.
     * @private
     * @param {Document|DocumentFragment} ownerDocument The document.
     * @param {Object} data of the document.
     */
    function shivMethods(ownerDocument, data) {
      if (!data.cache) {
          data.cache = {};
          data.createElem = ownerDocument.createElement;
          data.createFrag = ownerDocument.createDocumentFragment;
          data.frag = data.createFrag();
      }
  
  
      ownerDocument.createElement = function(nodeName) {
        //abort shiv
        if (!html5.shivMethods) {
            return data.createElem(nodeName);
        }
        return createElement(nodeName, ownerDocument, data);
      };
  
      ownerDocument.createDocumentFragment = Function('h,f', 'return function(){' +
        'var n=f.cloneNode(),c=n.createElement;' +
        'h.shivMethods&&(' +
          // unroll the `createElement` calls
          getElements().join().replace(/\w+/g, function(nodeName) {
            data.createElem(nodeName);
            data.frag.createElement(nodeName);
            return 'c("' + nodeName + '")';
          }) +
        ');return n}'
      )(html5, data.frag);
    }
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * Shivs the given document.
     * @memberOf html5
     * @param {Document} ownerDocument The document to shiv.
     * @returns {Document} The shived document.
     */
    function shivDocument(ownerDocument) {
      if (!ownerDocument) {
          ownerDocument = document;
      }
      var data = getExpandoData(ownerDocument);
  
      if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {
        data.hasCSS = !!addStyleSheet(ownerDocument,
          // corrects block display not defined in IE6/7/8/9
          'article,aside,figcaption,figure,footer,header,hgroup,nav,section{display:block}' +
          // adds styling not present in IE6/7/8/9
          'mark{background:#FF0;color:#000}'
        );
      }
      if (!supportsUnknownElements) {
        shivMethods(ownerDocument, data);
      }
      return ownerDocument;
    }
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * The `html5` object is exposed so that more elements can be shived and
     * existing shiving can be detected on iframes.
     * @type Object
     * @example
     *
     * // options can be changed before the script is included
     * html5 = { 'elements': 'mark section', 'shivCSS': false, 'shivMethods': false };
     */
    var html5 = {
  
      /**
       * An array or space separated string of node names of the elements to shiv.
       * @memberOf html5
       * @type Array|String
       */
      'elements': options.elements || 'abbr article aside audio bdi canvas data datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video',
  
      /**
       * A flag to indicate that the HTML5 style sheet should be inserted.
       * @memberOf html5
       * @type Boolean
       */
      'shivCSS': (options.shivCSS !== false),
  
      /**
       * Is equal to true if a browser supports creating unknown/HTML5 elements
       * @memberOf html5
       * @type boolean
       */
      'supportsUnknownElements': supportsUnknownElements,
  
      /**
       * A flag to indicate that the document's `createElement` and `createDocumentFragment`
       * methods should be overwritten.
       * @memberOf html5
       * @type Boolean
       */
      'shivMethods': (options.shivMethods !== false),
  
      /**
       * A string to describe the type of `html5` object ("default" or "default print").
       * @memberOf html5
       * @type String
       */
      'type': 'default',
  
      // shivs the document according to the specified `html5` object options
      'shivDocument': shivDocument,
  
      //creates a shived element
      createElement: createElement,
  
      //creates a shived documentFragment
      createDocumentFragment: createDocumentFragment
    };
  
    /*--------------------------------------------------------------------------*/
  
    // expose html5
    window.html5 = html5;
  
    // shiv the document
    shivDocument(document);
  
    /*------------------------------- Print Shiv -------------------------------*/
  
    /** Used to filter media types */
    var reMedia = /^$|\b(?:all|print)\b/;
  
    /** Used to namespace printable elements */
    var shivNamespace = 'html5shiv';
  
    /** Detect whether the browser supports shivable style sheets */
    var supportsShivableSheets = !supportsUnknownElements && (function() {
      // assign a false negative if unable to shiv
      var docEl = document.documentElement;
      return !(
        typeof document.namespaces == 'undefined' ||
        typeof document.parentWindow == 'undefined' ||
        typeof docEl.applyElement == 'undefined' ||
        typeof docEl.removeNode == 'undefined' ||
        typeof window.attachEvent == 'undefined'
      );
    }());
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * Wraps all HTML5 elements in the given document with printable elements.
     * (eg. the "header" element is wrapped with the "html5shiv:header" element)
     * @private
     * @param {Document} ownerDocument The document.
     * @returns {Array} An array wrappers added.
     */
    function addWrappers(ownerDocument) {
      var node,
          nodes = ownerDocument.getElementsByTagName('*'),
          index = nodes.length,
          reElements = RegExp('^(?:' + getElements().join('|') + ')$', 'i'),
          result = [];
  
      while (index--) {
        node = nodes[index];
        if (reElements.test(node.nodeName)) {
          result.push(node.applyElement(createWrapper(node)));
        }
      }
      return result;
    }
  
    /**
     * Creates a printable wrapper for the given element.
     * @private
     * @param {Element} element The element.
     * @returns {Element} The wrapper.
     */
    function createWrapper(element) {
      var node,
          nodes = element.attributes,
          index = nodes.length,
          wrapper = element.ownerDocument.createElement(shivNamespace + ':' + element.nodeName);
  
      // copy element attributes to the wrapper
      while (index--) {
        node = nodes[index];
        node.specified && wrapper.setAttribute(node.nodeName, node.nodeValue);
      }
      // copy element styles to the wrapper
      wrapper.style.cssText = element.style.cssText;
      return wrapper;
    }
  
    /**
     * Shivs the given CSS text.
     * (eg. header{} becomes html5shiv\:header{})
     * @private
     * @param {String} cssText The CSS text to shiv.
     * @returns {String} The shived CSS text.
     */
    function shivCssText(cssText) {
      var pair,
          parts = cssText.split('{'),
          index = parts.length,
          reElements = RegExp('(^|[\\s,>+~])(' + getElements().join('|') + ')(?=[[\\s,>+~#.:]|$)', 'gi'),
          replacement = '$1' + shivNamespace + '\\:$2';
  
      while (index--) {
        pair = parts[index] = parts[index].split('}');
        pair[pair.length - 1] = pair[pair.length - 1].replace(reElements, replacement);
        parts[index] = pair.join('}');
      }
      return parts.join('{');
    }
  
    /**
     * Removes the given wrappers, leaving the original elements.
     * @private
     * @params {Array} wrappers An array of printable wrappers.
     */
    function removeWrappers(wrappers) {
      var index = wrappers.length;
      while (index--) {
        wrappers[index].removeNode();
      }
    }
  
    /*--------------------------------------------------------------------------*/
  
    /**
     * Shivs the given document for print.
     * @memberOf html5
     * @param {Document} ownerDocument The document to shiv.
     * @returns {Document} The shived document.
     */
    function shivPrint(ownerDocument) {
      var shivedSheet,
          wrappers,
          data = getExpandoData(ownerDocument),
          namespaces = ownerDocument.namespaces,
          ownerWindow = ownerDocument.parentWindow;
  
      if (!supportsShivableSheets || ownerDocument.printShived) {
        return ownerDocument;
      }
      if (typeof namespaces[shivNamespace] == 'undefined') {
        namespaces.add(shivNamespace);
      }
  
      function removeSheet() {
        clearTimeout(data._removeSheetTimer);
        if (shivedSheet) {
            shivedSheet.removeNode(true);
        }
        shivedSheet= null;
      }
  
      ownerWindow.attachEvent('onbeforeprint', function() {
  
        removeSheet();
  
        var imports,
            length,
            sheet,
            collection = ownerDocument.styleSheets,
            cssText = [],
            index = collection.length,
            sheets = Array(index);
  
        // convert styleSheets collection to an array
        while (index--) {
          sheets[index] = collection[index];
        }
        // concat all style sheet CSS text
        while ((sheet = sheets.pop())) {
          // IE does not enforce a same origin policy for external style sheets...
          // but has trouble with some dynamically created stylesheets
          if (!sheet.disabled && reMedia.test(sheet.media)) {
  
            try {
              imports = sheet.imports;
              length = imports.length;
            } catch(er){
              length = 0;
            }
  
            for (index = 0; index < length; index++) {
              sheets.push(imports[index]);
            }
  
            try {
              cssText.push(sheet.cssText);
            } catch(er){}
          }
        }
  
        // wrap all HTML5 elements with printable elements and add the shived style sheet
        cssText = shivCssText(cssText.reverse().join(''));
        wrappers = addWrappers(ownerDocument);
        shivedSheet = addStyleSheet(ownerDocument, cssText);
  
      });
  
      ownerWindow.attachEvent('onafterprint', function() {
        // remove wrappers, leaving the original elements, and remove the shived style sheet
        removeWrappers(wrappers);
        clearTimeout(data._removeSheetTimer);
        data._removeSheetTimer = setTimeout(removeSheet, 500);
      });
  
      ownerDocument.printShived = true;
      return ownerDocument;
    }
  
    /*--------------------------------------------------------------------------*/
  
    // expose API
    html5.type += ' print';
    html5.shivPrint = shivPrint;
  
    // shiv for print
    shivPrint(document);
  
  }(this, document));/*yepnope1.5.4|WTFPL*/
  (function(a,b,c){function d(a){return"[object Function]"==o.call(a)}function e(a){return"string"==typeof a}function f(){}function g(a){return!a||"loaded"==a||"complete"==a||"uninitialized"==a}function h(){var a=p.shift();q=1,a?a.t?m(function(){("c"==a.t?B.injectCss:B.injectJs)(a.s,0,a.a,a.x,a.e,1)},0):(a(),h()):q=0}function i(a,c,d,e,f,i,j){function k(b){if(!o&&g(l.readyState)&&(u.r=o=1,!q&&h(),l.onload=l.onreadystatechange=null,b)){"img"!=a&&m(function(){t.removeChild(l)},50);for(var d in y[c])y[c].hasOwnProperty(d)&&y[c][d].onload()}}var j=j||B.errorTimeout,l=b.createElement(a),o=0,r=0,u={t:d,s:c,e:f,a:i,x:j};1===y[c]&&(r=1,y[c]=[]),"object"==a?l.data=c:(l.src=c,l.type=a),l.width=l.height="0",l.onerror=l.onload=l.onreadystatechange=function(){k.call(this,r)},p.splice(e,0,u),"img"!=a&&(r||2===y[c]?(t.insertBefore(l,s?null:n),m(k,j)):y[c].push(l))}function j(a,b,c,d,f){return q=0,b=b||"j",e(a)?i("c"==b?v:u,a,b,this.i++,c,d,f):(p.splice(this.i++,0,a),1==p.length&&h()),this}function k(){var a=B;return a.loader={load:j,i:0},a}var l=b.documentElement,m=a.setTimeout,n=b.getElementsByTagName("script")[0],o={}.toString,p=[],q=0,r="MozAppearance"in l.style,s=r&&!!b.createRange().compareNode,t=s?l:n.parentNode,l=a.opera&&"[object Opera]"==o.call(a.opera),l=!!b.attachEvent&&!l,u=r?"object":l?"script":"img",v=l?"script":u,w=Array.isArray||function(a){return"[object Array]"==o.call(a)},x=[],y={},z={timeout:function(a,b){return b.length&&(a.timeout=b[0]),a}},A,B;B=function(a){function b(a){var a=a.split("!"),b=x.length,c=a.pop(),d=a.length,c={url:c,origUrl:c,prefixes:a},e,f,g;for(f=0;f<d;f++)g=a[f].split("="),(e=z[g.shift()])&&(c=e(c,g));for(f=0;f<b;f++)c=x[f](c);return c}function g(a,e,f,g,h){var i=b(a),j=i.autoCallback;i.url.split(".").pop().split("?").shift(),i.bypass||(e&&(e=d(e)?e:e[a]||e[g]||e[a.split("/").pop().split("?")[0]]),i.instead?i.instead(a,e,f,g,h):(y[i.url]?i.noexec=!0:y[i.url]=1,f.load(i.url,i.forceCSS||!i.forceJS&&"css"==i.url.split(".").pop().split("?").shift()?"c":c,i.noexec,i.attrs,i.timeout),(d(e)||d(j))&&f.load(function(){k(),e&&e(i.origUrl,h,g),j&&j(i.origUrl,h,g),y[i.url]=2})))}function h(a,b){function c(a,c){if(a){if(e(a))c||(j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}),g(a,j,b,0,h);else if(Object(a)===a)for(n in m=function(){var b=0,c;for(c in a)a.hasOwnProperty(c)&&b++;return b}(),a)a.hasOwnProperty(n)&&(!c&&!--m&&(d(j)?j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}:j[n]=function(a){return function(){var b=[].slice.call(arguments);a&&a.apply(this,b),l()}}(k[n])),g(a[n],j,b,n,h))}else!c&&l()}var h=!!a.test,i=a.load||a.both,j=a.callback||f,k=j,l=a.complete||f,m,n;c(h?a.yep:a.nope,!!i),i&&c(i)}var i,j,l=this.yepnope.loader;if(e(a))g(a,0,l,0);else if(w(a))for(i=0;i<a.length;i++)j=a[i],e(j)?g(j,0,l,0):w(j)?B(j):Object(j)===j&&h(j,l);else Object(a)===a&&h(a,l)},B.addPrefix=function(a,b){z[a]=b},B.addFilter=function(a){x.push(a)},B.errorTimeout=1e4,null==b.readyState&&b.addEventListener&&(b.readyState="loading",b.addEventListener("DOMContentLoaded",A=function(){b.removeEventListener("DOMContentLoaded",A,0),b.readyState="complete"},0)),a.yepnope=k(),a.yepnope.executeStack=h,a.yepnope.injectJs=function(a,c,d,e,i,j){var k=b.createElement("script"),l,o,e=e||B.errorTimeout;k.src=a;for(o in d)k.setAttribute(o,d[o]);c=j?h:c||f,k.onreadystatechange=k.onload=function(){!l&&g(k.readyState)&&(l=1,c(),k.onload=k.onreadystatechange=null)},m(function(){l||(l=1,c(1))},e),i?k.onload():n.parentNode.insertBefore(k,n)},a.yepnope.injectCss=function(a,c,d,e,g,i){var e=b.createElement("link"),j,c=i?h:c||f;e.href=a,e.rel="stylesheet",e.type="text/css";for(j in d)e.setAttribute(j,d[j]);g||(n.parentNode.insertBefore(e,n),m(c,0))}})(this,document);
  Modernizr.load=function(){yepnope.apply(window,[].slice.call(arguments,0));};
  
  // a[download] attribute
  // When used on an <a>, this attribute signifies that the resource it
  // points to should be downloaded by the browser rather than navigating to it.
  // http://developers.whatwg.org/links.html#downloading-resources
  // By Addy Osmani
  
  Modernizr.addTest('adownload', 'download' in document.createElement('a'));
  // Web Audio API
  // https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html
  // By Addy Osmani
  Modernizr.addTest('webaudio', !!(window.webkitAudioContext || window.AudioContext));
  
  // Low Battery Level
  // Enable a developer to remove CPU intensive CSS/JS when battery is low
  // developer.mozilla.org/en/DOM/window.navigator.mozBattery
  // By: Paul Sayre
  
  Modernizr.addTest('lowbattery', function () {
  	var minLevel = 0.20,
  		battery = Modernizr.prefixed('battery', navigator);
  	return !!(battery && !battery.charging && battery.level <= minLevel);
  });
  // Blob constructor
  // http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob
  
  Modernizr.addTest('blobconstructor', function () {
      try {
          return !!new Blob();
      } catch (e) {
          return false;
      }
  });
  // Mozilla Audio Data API
  // https://wiki.mozilla.org/Audio_Data_API
  // by Addy Osmani
  Modernizr.addTest('audiodata', !!(window.Audio));
  
  // Battery API
  // https://developer.mozilla.org/en/DOM/window.navigator.mozBattery
  // By: Paul Sayre
  
  Modernizr.addTest('battery',
  	!!Modernizr.prefixed('battery', navigator)
  );// contentEditable
  // http://www.whatwg.org/specs/web-apps/current-work/multipage/editing.html#contenteditable
  
  // this is known to false positive in some mobile browsers
  // here is a whitelist of verified working browsers:
  // https://github.com/NielsLeenheer/html5test/blob/549f6eac866aa861d9649a0707ff2c0157895706/scripts/engine.js#L2083
  
  Modernizr.addTest('contenteditable',
          'contentEditable' in document.documentElement);
  // canvas.toDataURL type support
  // http://www.w3.org/TR/html5/the-canvas-element.html#dom-canvas-todataurl
  
  // This test is asynchronous. Watch out.
  
  (function () {
  
      if (!Modernizr.canvas) {
          return false;
      }
  
      var image = new Image(),
          canvas = document.createElement('canvas'),
          ctx = canvas.getContext('2d');
  
      image.onload = function() {
          ctx.drawImage(image, 0, 0);
  
          Modernizr.addTest('todataurljpeg', function() {
              return canvas.toDataURL('image/jpeg').indexOf('data:image/jpeg') === 0;
          });
          Modernizr.addTest('todataurlwebp', function() {
              return canvas.toDataURL('image/webp').indexOf('data:image/webp') === 0;
          });
      };
  
      image.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==';
  }());
  // Test for (experimental) Content Security Policy 1.1 support.
  //
  // This feature is still quite experimental, but is available now in Chrome 22.
  // If the `SecurityPolicy` property is available, you can be sure the browser
  // supports CSP. If it's not available, the browser still might support an
  // earlier version of the CSP spec.
  //
  // Editor's Draft: https://dvcs.w3.org/hg/content-security-policy/raw-file/tip/csp-specification.dev.html
  
  Modernizr.addTest('contentsecuritypolicy', 'SecurityPolicy' in document);
  
  // by tauren
  // https://github.com/Modernizr/Modernizr/issues/191
  
  Modernizr.addTest('cookies', function () {
    // Quick test if browser has cookieEnabled host property
    if (navigator.cookieEnabled) return true;
    // Create cookie
    document.cookie = "cookietest=1";
    var ret = document.cookie.indexOf("cookietest=") != -1;
    // Delete cookie
    document.cookie = "cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT";
    return ret;
  });
  
  // http://www.w3.org/TR/html5/interactive-elements.html#context-menus
  // Demo at http://thewebrocks.com/demos/context-menu/
  Modernizr.addTest(
    'contextmenu', 
    ('contextMenu' in document.documentElement && 'HTMLMenuItemElement' in window) 
  );
  
  
  
  
  
  // cors
  // By Theodoor van Donge
  Modernizr.addTest('cors', !!(window.XMLHttpRequest && 'withCredentials' in new XMLHttpRequest()));/*
      https://developer.mozilla.org/en/CSS/background-position
      http://www.w3.org/TR/css3-background/#background-position
  
      Example: http://jsfiddle.net/Blink/bBXvt/
  */
  
  (function() {
  
      var elem = document.createElement('a'),
          eStyle = elem.style,
          val = "right 10px bottom 10px";
  
      Modernizr.addTest('bgpositionshorthand', function(){
          eStyle.cssText = "background-position: " + val + ";";
          return (eStyle.backgroundPosition === val);
      });
  
  }());
  /*
  	Allan Lei https://github.com/allanlei
  	
  	Check adapted from https://github.com/brandonaaron/jquery-cssHooks/blob/master/bgpos.js
  	
  	Test: http://jsfiddle.net/allanlei/R8AYS/
  */
  Modernizr.addTest('bgpositionxy', function() {
      return Modernizr.testStyles('#modernizr {background-position: 3px 5px;}', function(elem) {
          var cssStyleDeclaration = window.getComputedStyle ? getComputedStyle(elem, null) : elem.currentStyle;
          var xSupport = (cssStyleDeclaration.backgroundPositionX == '3px') || (cssStyleDeclaration['background-position-x'] == '3px');
          var ySupport = (cssStyleDeclaration.backgroundPositionY == '5px') || (cssStyleDeclaration['background-position-y'] == '5px');
          return xSupport && ySupport;
      });
  });
  // developer.mozilla.org/en/CSS/box-sizing
  // github.com/Modernizr/Modernizr/issues/248
  
  Modernizr.addTest("boxsizing",function(){
      return Modernizr.testAllProps("boxSizing") && (document.documentMode === undefined || document.documentMode > 7);
  });
  
  
  // Method of allowing calculated values for length units, i.e. width: calc(100%-3em) http://caniuse.com/#search=calc
  // By @calvein
  
  Modernizr.addTest('csscalc', function() {
      var prop = 'width:';
      var value = 'calc(10px);';
      var el = document.createElement('div');
  
      el.style.cssText = prop + Modernizr._prefixes.join(value + prop);
  
      return !!el.style.length;
  });
  
  // developer.mozilla.org/en/CSS/background-size
  
  Modernizr.testStyles( '#modernizr{background-size:cover}', function( elem ) {
  	var style = window.getComputedStyle ?
  		window.getComputedStyle( elem, null )
  		: elem.currentStyle;
  		
  	Modernizr.addTest( 'bgsizecover', style.backgroundSize == 'cover' );
  });// developer.mozilla.org/en/CSS/background-repeat
  
  // test page: jsbin.com/uzesun/
  // http://jsfiddle.net/ryanseddon/yMLTQ/6/    
  
  (function(){
  
  
  function getBgRepeatValue(elem){
      return (window.getComputedStyle ?
               getComputedStyle(elem, null).getPropertyValue('background') :
               elem.currentStyle['background']);
  }
    
  
  Modernizr.testStyles(' #modernizr { background-repeat: round; } ', function(elem, rule){ 
  
    Modernizr.addTest('bgrepeatround', getBgRepeatValue(elem) == 'round');
  
  });
  
  
  
  Modernizr.testStyles(' #modernizr { background-repeat: space; } ', function(elem, rule){ 
  
    Modernizr.addTest('bgrepeatspace', getBgRepeatValue(elem) == 'space');
  
  });
  
  
  })();
  // cubic-bezier values can't be > 1 for Webkit until bug #45761 (https://bugs.webkit.org/show_bug.cgi?id=45761) is fixed
  // By @calvein
  
  Modernizr.addTest('cubicbezierrange', function() {
      var el = document.createElement('div');
      el.style.cssText = Modernizr._prefixes.join('transition-timing-function' + ':cubic-bezier(1,0,0,1.1); ');
      return !!el.style.length;
  });
  
  // by alanhogan
  
  // https://github.com/Modernizr/Modernizr/issues/198
  // http://css-tricks.com/596-run-in/
  
  
  
  Modernizr.testStyles(' #modernizr { display: run-in; } ', function(elem, rule){ 
  
    var ret = (window.getComputedStyle ?
           getComputedStyle(elem, null).getPropertyValue('display') :
           elem.currentStyle['display']);
  
    Modernizr.addTest('display-runin', ret == 'run-in');
  
  });
  
  // display: table and table-cell test. (both are tested under one name "table-cell" )
  // By @scottjehl
  
  // all additional table display values are here: http://pastebin.com/Gk9PeVaQ though Scott has seen some IE false positives with that sort of weak detection.
  // more testing neccessary perhaps.
  
  Modernizr.addTest( "display-table",function(){
    
    var doc   = window.document,
        docElem = doc.documentElement,   
        parent  = doc.createElement( "div" ),
        child = doc.createElement( "div" ),
        childb  = doc.createElement( "div" ),
        ret;
    
    parent.style.cssText = "display: table";
    child.style.cssText = childb.style.cssText = "display: table-cell; padding: 10px";    
            
    parent.appendChild( child );
    parent.appendChild( childb );
    docElem.insertBefore( parent, docElem.firstChild );
    
    ret = child.offsetLeft < childb.offsetLeft;
    docElem.removeChild(parent);
    return ret; 
  });
  
  // https://github.com/Modernizr/Modernizr/issues/615
  // documentMode is needed for false positives in oldIE, please see issue above
  Modernizr.addTest('cssfilters', function() {
      var el = document.createElement('div');
      el.style.cssText = Modernizr._prefixes.join('filter' + ':blur(2px); ');
      return !!el.style.length && ((document.documentMode === undefined || document.documentMode > 9));
  });// last-child pseudo selector
  // https://github.com/Modernizr/Modernizr/pull/304
  
  
  Modernizr.addTest('lastchild', function(){
  
    return Modernizr.testStyles("#modernizr div {width:100px} #modernizr :last-child{width:200px;display:block}", function (elem) {
      return elem.lastChild.offsetWidth > elem.firstChild.offsetWidth;
    }, 2);
  
  });
  /* see http://davidnewton.ca/the-current-state-of-hyphenation-on-the-web
     http://davidnewton.ca/demos/hyphenation/test.html
  
  
  There are three tests:
     1. csshyphens      - tests hyphens:auto actually adds hyphens to text
     2. softhyphens     - tests that &shy; does its job
     3. softhyphensfind - tests that in-browser Find functionality still works correctly with &shy;
  
  These tests currently require document.body to be present
  
  Hyphenation is language specific, sometimes.
    See for more details: http://code.google.com/p/hyphenator/source/diff?spec=svn975&r=975&format=side&path=/trunk/Hyphenator.js#sc_svn975_313
  
  If loading Hyphenator.js via Modernizr.load, be cautious of issue 158: http://code.google.com/p/hyphenator/issues/detail?id=158
  
  More details at https://github.com/Modernizr/Modernizr/issues/312
  
  */
  
  (function() {
  
  	if (!document.body){
  		window.console && console.warn('document.body doesn\'t exist. Modernizr hyphens test needs it.');
  		return;
  	}
  
  	// functional test of adding hyphens:auto
  	function test_hyphens_css() {
  		try {
  			/* create a div container and a span within that
  			 * these have to be appended to document.body, otherwise some browsers can give false negative */
  			var div = document.createElement('div'),
  				span = document.createElement('span'),
  				divStyle = div.style,
  				spanHeight = 0,
  				spanWidth = 0,
  				result = false,
  				firstChild = document.body.firstElementChild || document.body.firstChild;
  
  			div.appendChild(span);
  			span.innerHTML = 'Bacon ipsum dolor sit amet jerky velit in culpa hamburger et. Laborum dolor proident, enim dolore duis commodo et strip steak. Salami anim et, veniam consectetur dolore qui tenderloin jowl velit sirloin. Et ad culpa, fatback cillum jowl ball tip ham hock nulla short ribs pariatur aute. Pig pancetta ham bresaola, ut boudin nostrud commodo flank esse cow tongue culpa. Pork belly bresaola enim pig, ea consectetur nisi. Fugiat officia turkey, ea cow jowl pariatur ullamco proident do laborum velit sausage. Magna biltong sint tri-tip commodo sed bacon, esse proident aliquip. Ullamco ham sint fugiat, velit in enim sed mollit nulla cow ut adipisicing nostrud consectetur. Proident dolore beef ribs, laborum nostrud meatball ea laboris rump cupidatat labore culpa. Shankle minim beef, velit sint cupidatat fugiat tenderloin pig et ball tip. Ut cow fatback salami, bacon ball tip et in shank strip steak bresaola. In ut pork belly sed mollit tri-tip magna culpa veniam, short ribs qui in andouille ham consequat. Dolore bacon t-bone, velit short ribs enim strip steak nulla. Voluptate labore ut, biltong swine irure jerky. Cupidatat excepteur aliquip salami dolore. Ball tip strip steak in pork dolor. Ad in esse biltong. Dolore tenderloin exercitation ad pork loin t-bone, dolore in chicken ball tip qui pig. Ut culpa tongue, sint ribeye dolore ex shank voluptate hamburger. Jowl et tempor, boudin pork chop labore ham hock drumstick consectetur tri-tip elit swine meatball chicken ground round. Proident shankle mollit dolore. Shoulder ut duis t-bone quis reprehenderit. Meatloaf dolore minim strip steak, laboris ea aute bacon beef ribs elit shank in veniam drumstick qui. Ex laboris meatball cow tongue pork belly. Ea ball tip reprehenderit pig, sed fatback boudin dolore flank aliquip laboris eu quis. Beef ribs duis beef, cow corned beef adipisicing commodo nisi deserunt exercitation. Cillum dolor t-bone spare ribs, ham hock est sirloin. Brisket irure meatloaf in, boudin pork belly sirloin ball tip. Sirloin sint irure nisi nostrud aliqua. Nostrud nulla aute, enim officia culpa ham hock. Aliqua reprehenderit dolore sunt nostrud sausage, ea boudin pork loin ut t-bone ham tempor. Tri-tip et pancetta drumstick laborum. Ham hock magna do nostrud in proident. Ex ground round fatback, venison non ribeye in.';
  
  			document.body.insertBefore(div, firstChild);
  
  			/* get size of unhyphenated text */
  			divStyle.cssText = 'position:absolute;top:0;left:0;width:5em;text-align:justify;text-justification:newspaper;';
  			spanHeight = span.offsetHeight;
  			spanWidth = span.offsetWidth;
  
  			/* compare size with hyphenated text */
  			divStyle.cssText = 'position:absolute;top:0;left:0;width:5em;text-align:justify;'+
  												 'text-justification:newspaper;'+
  												 Modernizr._prefixes.join('hyphens:auto; ');
  
  			result = (span.offsetHeight != spanHeight || span.offsetWidth != spanWidth);
  
  			/* results and cleanup */
  			document.body.removeChild(div);
  			div.removeChild(span);
  
  			return result;
  		} catch(e) {
  			return false;
  		}
  	}
  
  	// for the softhyphens test
  	function test_hyphens(delimiter, testWidth) {
  		try {
  			/* create a div container and a span within that
  			 * these have to be appended to document.body, otherwise some browsers can give false negative */
  			var div = document.createElement('div'),
  				span = document.createElement('span'),
  				divStyle = div.style,
  				spanSize = 0,
  				result = false,
  				result1 = false,
  				result2 = false,
  				firstChild = document.body.firstElementChild || document.body.firstChild;
  
  			divStyle.cssText = 'position:absolute;top:0;left:0;overflow:visible;width:1.25em;';
  			div.appendChild(span);
  			document.body.insertBefore(div, firstChild);
  
  
  			/* get height of unwrapped text */
  			span.innerHTML = 'mm';
  			spanSize = span.offsetHeight;
  
  			/* compare height w/ delimiter, to see if it wraps to new line */
  			span.innerHTML = 'm' + delimiter + 'm';
  			result1 = (span.offsetHeight > spanSize);
  
  			/* if we're testing the width too (i.e. for soft-hyphen, not zws),
  			 * this is because tested Blackberry devices will wrap the text but not display the hyphen */
  			if (testWidth) {
  				/* get width of wrapped, non-hyphenated text */
  				span.innerHTML = 'm<br />m';
  				spanSize = span.offsetWidth;
  
  				/* compare width w/ wrapped w/ delimiter to see if hyphen is present */
  				span.innerHTML = 'm' + delimiter + 'm';
  				result2 = (span.offsetWidth > spanSize);
  			} else {
  				result2 = true;
  			}
  
  			/* results and cleanup */
  			if (result1 === true && result2 === true) { result = true; }
  			document.body.removeChild(div);
  			div.removeChild(span);
  
  			return result;
  		} catch(e) {
  			return false;
  		}
  	}
  
  	// testing if in-browser Find functionality will work on hyphenated text
  	function test_hyphens_find(delimiter) {
  		try {
  			/* create a dummy input for resetting selection location, and a div container
  			 * these have to be appended to document.body, otherwise some browsers can give false negative
  			 * div container gets the doubled testword, separated by the delimiter
  			 * Note: giving a width to div gives false positive in iOS Safari */
  			var dummy = document.createElement('input'),
  				div = document.createElement('div'),
  				testword = 'lebowski',
  				result = false,
  				textrange,
  				firstChild = document.body.firstElementChild || document.body.firstChild;
  
  			div.innerHTML = testword + delimiter + testword;
  
  			document.body.insertBefore(div, firstChild);
  			document.body.insertBefore(dummy, div);
  
  
  			/* reset the selection to the dummy input element, i.e. BEFORE the div container
  			 *   stackoverflow.com/questions/499126/jquery-set-cursor-position-in-text-area */
  			if (dummy.setSelectionRange) {
  				dummy.focus();
  				dummy.setSelectionRange(0,0);
  			} else if (dummy.createTextRange) {
  				textrange = dummy.createTextRange();
  				textrange.collapse(true);
  				textrange.moveEnd('character', 0);
  				textrange.moveStart('character', 0);
  				textrange.select();
  			}
  
  			/* try to find the doubled testword, without the delimiter */
  			if (window.find) {
  				result = window.find(testword + testword);
  			} else {
  				try {
  					textrange = window.self.document.body.createTextRange();
  					result = textrange.findText(testword + testword);
  				} catch(e) {
  					result = false;
  				}
  			}
  
  			document.body.removeChild(div);
  			document.body.removeChild(dummy);
  
  			return result;
  		} catch(e) {
  			return false;
  		}
  	}
  
  	Modernizr.addTest("csshyphens", function() {
  
  		if (!Modernizr.testAllProps('hyphens')) return false;
  
  		/* Chrome lies about its hyphens support so we need a more robust test
  				crbug.com/107111
  		*/
  		try {
  			return test_hyphens_css();
  		} catch(e) {
  			return false;
  		}
  	});
  
  	Modernizr.addTest("softhyphens", function() {
  		try {
  			// use numeric entity instead of &shy; in case it's XHTML
  			return test_hyphens('&#173;', true) && test_hyphens('&#8203;', false);
  		} catch(e) {
  			return false;
  		}
  	});
  
  	Modernizr.addTest("softhyphensfind", function() {
  		try {
  			return test_hyphens_find('&#173;') && test_hyphens_find('&#8203;');
  		} catch(e) {
  			return false;
  		}
  	});
  
  })();
  
  // this tests passes for webkit's proprietary `-webkit-mask` feature
  //   www.webkit.org/blog/181/css-masks/
  //   developer.apple.com/library/safari/#documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Masks/Masks.html
  
  // it does not pass mozilla's implementation of `mask` for SVG
  
  //   developer.mozilla.org/en/CSS/mask
  //   developer.mozilla.org/En/Applying_SVG_effects_to_HTML_content
  
  // Can combine with clippaths for awesomeness: http://generic.cx/for/webkit/test.html
  
  Modernizr.addTest('cssmask', Modernizr.testAllProps('mask-repeat'));
  
  
  Modernizr.addTest('mediaqueries', Modernizr.mq('only all'));
  // johanbrook.com/browsers/native-momentum-scrolling-ios-5/
  // introduced in iOS5b2. Possible API may change...
  
  Modernizr.addTest("overflowscrolling",function(){
      return Modernizr.testAllProps("overflowScrolling");
  });
  
  
  
  // dev.opera.com/articles/view/css3-object-fit-object-position/
  
  Modernizr.addTest('object-fit',
  	!!Modernizr.prefixed('objectFit')
  );
  // developer.mozilla.org/en/CSS/pointer-events
  
  // Test and project pages:
  // ausi.github.com/Feature-detection-technique-for-pointer-events/
  // github.com/ausi/Feature-detection-technique-for-pointer-events/wiki
  // github.com/Modernizr/Modernizr/issues/80
  
  
  Modernizr.addTest('pointerevents', function(){
      var element = document.createElement('x'),
          documentElement = document.documentElement,
          getComputedStyle = window.getComputedStyle,
          supports;
      if(!('pointerEvents' in element.style)){
          return false;
      }
      element.style.pointerEvents = 'auto';
      element.style.pointerEvents = 'x';
      documentElement.appendChild(element);
      supports = getComputedStyle &&
          getComputedStyle(element, '').pointerEvents === 'auto';
      documentElement.removeChild(element);
      return !!supports;
  });
  // Sticky positioning - constrains an element to be positioned inside the
  // intersection of its container box, and the viewport.
  Modernizr.addTest('csspositionsticky', function () {
  
      var prop = 'position:';
      var value = 'sticky';
      var el = document.createElement('modernizr');
      var mStyle = el.style;
  
      mStyle.cssText = prop + Modernizr._prefixes.join(value + ';' + prop).slice(0, -prop.length);
  
      return mStyle.position.indexOf(value) !== -1;
  });
  
  // test by github.com/nsfmc
  
  // "The 'rem' unit ('root em') is relative to the computed
  // value of the 'font-size' value of the root element."
  // http://www.w3.org/TR/css3-values/#relative0
  // you can test by checking if the prop was ditched
  
  // http://snook.ca/archives/html_and_css/font-size-with-rem
  
  Modernizr.addTest('cssremunit', function(){
  
    var div = document.createElement('div');
    try {
      div.style.fontSize = '3rem';
    } catch(er){}
    return (/rem/).test(div.style.fontSize);
  
  });
  // Stylable scrollbars detection
  Modernizr.addTest('cssscrollbar', function() {
  
  	var bool,
  
  		styles = "#modernizr{overflow: scroll; width: 40px }#" +
  			Modernizr._prefixes
  				.join("scrollbar{width:0px}"+' #modernizr::')
  				.split('#')
  				.slice(1)
  				.join('#') + "scrollbar{width:0px}";
  
  	Modernizr.testStyles(styles, function(node) {
  		bool = 'scrollWidth' in node && node.scrollWidth == 40;
  	});
  
  	return bool;
  
  });
  
  // Test for CSS 3 UI "resize" property
  // http://www.w3.org/TR/css3-ui/#resize
  // https://developer.mozilla.org/en/CSS/resize
  
  Modernizr.addTest('cssresize', Modernizr.testAllProps('resize'));
  
  
  // CSS Regions
  // http://www.w3.org/TR/css3-regions/
  // By: Mihai Balan
  
  // We start with a CSS parser test then we check page geometry to see if it's affected by regions
  // Later we might be able to retire the second part, as WebKit builds with the false positives die out
  
  Modernizr.addTest('regions', function() {
  
  	/* Get the 'flowFrom' property name available in the browser. Either default or vendor prefixed.
  	If the property name can't be found we'll get Boolean 'false' and fail quickly */
  	var flowFromProperty = Modernizr.prefixed("flowFrom"),
  		flowIntoProperty = Modernizr.prefixed("flowInto");
  
  	if (!flowFromProperty || !flowIntoProperty){
  		return false;
  	}
  
  	/* If CSS parsing is there, try to determine if regions actually work. */
  	var container		= document.createElement('div'),
  		content			= document.createElement('div'),
  		region			= document.createElement('div'),
  
  	/* we create a random, unlikely to be generated flow number to make sure we don't
  	clash with anything more vanilla, like 'flow', or 'article', or 'f1' */
  	flowName = 'modernizr_flow_for_regions_check';
  
  	/* First create a div with two adjacent divs inside it. The first will be the
  	content, the second will be the region. To be able to distinguish between the two,
  	we'll give the region a particular padding */
  	content.innerText		= 'M';
  	container.style.cssText	= 'top: 150px; left: 150px; padding: 0px;';
  	region.style.cssText	= 'width: 50px; height: 50px; padding: 42px;';
  
  	region.style[flowFromProperty] = flowName;
  	container.appendChild(content);
  	container.appendChild(region);
  	document.documentElement.appendChild(container);
  
  	/* Now compute the bounding client rect, before and after attempting to flow the
  	content div in the region div. If regions are enabled, the after bounding rect
  	should reflect the padding of the region div.*/
  	var flowedRect, delta,
  		plainRect = content.getBoundingClientRect();
  
  
  	content.style[flowIntoProperty] = flowName;
  	flowedRect = content.getBoundingClientRect();
  
  	delta = flowedRect.left - plainRect.left;
  	document.documentElement.removeChild(container);
  	content = region = container = undefined;
  
  	return (delta == 42);
  });
  /*
   * Test for SubPixel Font Rendering
   * (to infer if GDI or DirectWrite is used on Windows)
   * Authors: @derSchepp, @gerritvanaaken, @rodneyrehm, @yatil, @ryanseddon
   * Web: https://github.com/gerritvanaaken/subpixeldetect
   */
  Modernizr.addTest('subpixelfont', function() {
      var bool,
          styles = "#modernizr{position: absolute; top: -10em; visibility:hidden; font: normal 10px arial;}#subpixel{float: left; font-size: 33.3333%;}";
      
      // see https://github.com/Modernizr/Modernizr/blob/master/modernizr.js#L97
      Modernizr.testStyles(styles, function(elem) {
          var subpixel = elem.firstChild;
  
          subpixel.innerHTML = 'This is a text written in Arial';
  
          bool = window.getComputedStyle ?
              window.getComputedStyle(subpixel, null).getPropertyValue("width") !== '44px'
              : false;
      }, 1, ['subpixel']);
  
      return bool;
  });
  // http://dev.w3.org/csswg/css3-conditional/#at-supports
  // github.com/Modernizr/Modernizr/issues/648
  // Relies on the fact that a browser vendor should expose the CSSSupportsRule interface
  // http://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface
  
  Modernizr.addTest("supports","CSSSupportsRule" in window);// -moz-user-select:none test.
  
  // by ryan seddon
  //https://github.com/Modernizr/Modernizr/issues/250
  
  
  Modernizr.addTest("userselect",function(){
      return Modernizr.testAllProps("user-select");
  });
  
  // https://github.com/Modernizr/Modernizr/issues/572
  // Similar to http://jsfiddle.net/FWeinb/etnYC/
  Modernizr.addTest('cssvhunit', function() {
      var bool;
      Modernizr.testStyles("#modernizr { height: 50vh; }", function(elem, rule) {   
          var height = parseInt(window.innerHeight/2,10),
              compStyle = parseInt((window.getComputedStyle ?
                        getComputedStyle(elem, null) :
                        elem.currentStyle)["height"],10);
          
          bool= (compStyle == height);
      });
      return bool;
  });// https://github.com/Modernizr/Modernizr/issues/572
  // http://jsfiddle.net/glsee/JDsWQ/4/
  Modernizr.addTest('cssvmaxunit', function(){
      var bool;
      Modernizr.testStyles("#modernizr { width: 50vmax; }", function(elem, rule) {
          var one_vw = window.innerWidth/100,
              one_vh = window.innerHeight/100,
              compWidth = parseInt((window.getComputedStyle ?
                                    getComputedStyle(elem, null) :
                                    elem.currentStyle)['width'],10);
          bool = ( parseInt(Math.max(one_vw, one_vh)*50,10) == compWidth );
      });
      return bool;
  });// https://github.com/Modernizr/Modernizr/issues/572
  // http://jsfiddle.net/FWeinb/etnYC/
  Modernizr.addTest('cssvwunit', function(){
      var bool;
      Modernizr.testStyles("#modernizr { width: 50vw; }", function(elem, rule) {
          var width = parseInt(window.innerWidth/2,10),
              compStyle = parseInt((window.getComputedStyle ?
                        getComputedStyle(elem, null) :
                        elem.currentStyle)["width"],10);
          
          bool= (compStyle == width);
      });
      return bool;
  });
  /*
  	Custom protocol handler support
  	http://developers.whatwg.org/timers.html#custom-handlers
  	
  	Added by @benschwarz
  */
  
  Modernizr.addTest('customprotocolhandler', function () {
      return !!navigator.registerProtocolHandler;
  });
  // https://github.com/Modernizr/Modernizr/issues/572
  // http://jsfiddle.net/glsee/JRmdq/8/
  Modernizr.addTest('cssvminunit', function(){
      var bool;
      Modernizr.testStyles("#modernizr { width: 50vmin; }", function(elem, rule) {
          var one_vw = window.innerWidth/100,
              one_vh = window.innerHeight/100,
              compWidth = parseInt((window.getComputedStyle ?
                                    getComputedStyle(elem, null) :
                                    elem.currentStyle)['width'],10);
          bool = ( parseInt(Math.min(one_vw, one_vh)*50,10) == compWidth );
      });
      return bool;
  });
  // DataView 
  // https://developer.mozilla.org/en/JavaScript_typed_arrays/DataView
  // By Addy Osmani
  Modernizr.addTest('dataview', (typeof DataView !== 'undefined' && 'getFloat64' in DataView.prototype));// classList
  // https://developer.mozilla.org/en/DOM/element.classList
  // By Addy Osmani
  Modernizr.addTest('classlist', 'classList' in document.documentElement);
  // by james a rosen.
  // https://github.com/Modernizr/Modernizr/issues/258
  
  Modernizr.addTest('createelement-attrs', function() {
    try {
      return document.createElement("<input name='test' />").getAttribute('name') == 'test';
    } catch(e) {
      return false;
    }
  });
  
  
  // dataset API for data-* attributes
  // test by @phiggins42
  
  Modernizr.addTest('dataset', function(){
    var n = document.createElement("div");
    n.setAttribute("data-a-b", "c");
    return !!(n.dataset && n.dataset.aB === "c");
  });
  // Microdata support
  // http://www.w3.org/TR/html5/microdata.html
  // By Addy Osmani
  Modernizr.addTest('microdata', !!(document['getItems']));
  
  // lol. we already have a test for datalist built in! silly you.
  
  
  // Helpful links while you're here, though..
  
  // http://css-tricks.com/15346-relevant-dropdowns-polyfill-for-datalist/
  // http://miketaylr.com/test/datalist.html
  // http://miketaylr.com/code/datalist.html
  
  Modernizr.addTest('datalistelem', Modernizr.input.list );
  // By @mathias, based on http://mths.be/axh
  Modernizr.addTest('details', function() {
      var doc = document,
          el = doc.createElement('details'),
          fake,
          root,
          diff;
      if (!('open' in el)) { // return early if possible; thanks @aFarkas!
          return false;
      }
      root = doc.body || (function() {
          var de = doc.documentElement;
          fake = true;
          return de.insertBefore(doc.createElement('body'), de.firstElementChild || de.firstChild);
      }());
      el.innerHTML = '<summary>a</summary>b';
      el.style.display = 'block';
      root.appendChild(el);
      diff = el.offsetHeight;
      el.open = true;
      diff = diff != el.offsetHeight;
      root.removeChild(el);
      fake && root.parentNode.removeChild(root);
      return diff;
  });// <output>
  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-button-element.html#the-output-element
  // by Addy Osmani
  Modernizr.addTest('outputelem', 'value' in document.createElement('output'));
  //By Stefan Wallin
  
  //tests for progressbar-support. All browsers that don't support progressbar returns undefined =)
  Modernizr.addTest("progressbar",function(){
      return document.createElement('progress').max !== undefined;
  });
  
  //tests for meter-support. All browsers that don't support meters returns undefined =)
  Modernizr.addTest("meter",function(){
      return document.createElement('meter').max !== undefined;
  });
  // Browser support test for the HTML5 <ruby>, <rt> and <rp> elements
  // http://www.whatwg.org/specs/web-apps/current-work/multipage/text-level-semantics.html#the-ruby-element
  //
  // by @alrra
  
  Modernizr.addTest('ruby', function () {
  
      var ruby = document.createElement('ruby'),
          rt = document.createElement('rt'),
          rp = document.createElement('rp'),
          docElement = document.documentElement,
          displayStyleProperty = 'display',
          fontSizeStyleProperty = 'fontSize'; // 'fontSize' - because it`s only used for IE6 and IE7
  
      ruby.appendChild(rp);
      ruby.appendChild(rt);
      docElement.appendChild(ruby);
  
      // browsers that support <ruby> hide the <rp> via "display:none"
      if ( getStyle(rp, displayStyleProperty) == 'none' ||                                                       // for non-IE browsers
      // but in IE browsers <rp> has "display:inline" so, the test needs other conditions:
          getStyle(ruby, displayStyleProperty) == 'ruby' && getStyle(rt, displayStyleProperty) == 'ruby-text' || // for IE8 & IE9
          getStyle(rp, fontSizeStyleProperty) == '6pt' && getStyle(rt, fontSizeStyleProperty) == '6pt' ) {       // for IE6 & IE7
  
          cleanUp();
          return true;
  
      } else {
          cleanUp();
          return false;
      }
  
      function getStyle( element, styleProperty ) {
          var result;
  
          if ( window.getComputedStyle ) {     // for non-IE browsers
              result = document.defaultView.getComputedStyle(element,null).getPropertyValue(styleProperty);
          } else if ( element.currentStyle ) { // for IE
              result = element.currentStyle[styleProperty];
          }
  
          return result;
      }
  
      function cleanUp() {
          docElement.removeChild(ruby);
          // the removed child node still exists in memory, so ...
          ruby = null;
          rt = null;
          rp = null;
      }
  
  });
  // Track element + Timed Text Track API
  // http://www.w3.org/TR/html5/video.html#the-track-element
  // http://www.w3.org/TR/html5/media-elements.html#text-track-api
  //
  // While IE10 has implemented the track element, IE10 does not expose the underlying APIs to create timed text tracks by JS (really sad)
  // By Addy Osmani
  Modernizr.addTest({
  	texttrackapi: (typeof (document.createElement('video').addTextTrack) === 'function'),
  	// a more strict test for track including UI support: document.createElement('track').kind === 'subtitles'
  	track: ('kind' in document.createElement('track'))
  });
  // <time> element
  // http://www.whatwg.org/specs/web-apps/current-work/multipage/rendering.html#the-time-element-0
  // by Addy Osmani
  Modernizr.addTest('time', 'valueAsDate' in document.createElement('time'));
  // Requires a Modernizr build with `canvastext` included
  // http://www.modernizr.com/download/#-canvas-canvastext
  Modernizr.addTest('emoji', function() {
    if (!Modernizr.canvastext) return false;
    var node = document.createElement('canvas'),
        ctx = node.getContext('2d');
    ctx.textBaseline = 'top';
    ctx.font = '32px Arial';
    ctx.fillText('\ud83d\ude03', 0, 0); // "smiling face with open mouth" emoji
    return ctx.getImageData(16, 16, 1, 1).data[0] !== 0;
  });// strict mode
  
  // test by @kangax
  
  Modernizr.addTest('strictmode', function(){
  	return (function(){ "use strict"; return !this; })(); 
  });//By Shi Chuan
  //Part of Device Access aspect of HTML5, same category as geolocation
  //W3C Editor's Draft at http://dev.w3.org/geo/api/spec-source-orientation.html
  //Implementation by iOS Safari at http://goo.gl/fhce3 and http://goo.gl/rLKz8
  
  
  //test for Device Motion Event support, returns boolean value true/false
  Modernizr.addTest('devicemotion', ('DeviceMotionEvent' in window) );
  
  //test for Device Orientation Event support, returns boolean value true/false
  Modernizr.addTest('deviceorientation', ('DeviceOrientationEvent' in window) );
  // EXIF Orientation test
  
  // iOS looks at the EXIF Orientation flag in jpgs and rotates the image
  // accordingly. Looks like most desktop browsers just ignore this data.
  
  // description: www.impulseadventure.com/photo/exif-orientation.html
  
  // Bug trackers:
  //    bugzil.la/298619 (unimplemented)
  //    crbug.com/56845 (looks incomplete)
  //    webk.it/19688 (available upstream but its up all ports to turn on individually)
  //
  
  // detect by Paul Sayre
  
  
  (function(){
  
    var img = new Image();
  
    img.onerror = function() {
        Modernizr.addTest('exif-orientation', function () { return false; });
    };
  
    img.onload = function() {
        Modernizr.addTest('exif-orientation', function () { return img.width !== 2; });
    };
  
    // There may be a way to shrink this more, it's a 1x2 white jpg with the orientation flag set to 6
    img.src = "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/4QAiRXhpZgAASUkqAAgAAAABABIBAwABAAAABgASAAAAAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAARCAABAAIDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+/iiiigD/2Q==";
  
  })();
  /**
   * file tests for the File API specification
   *   Tests for objects specific to the File API W3C specification without
   *   being redundant (don't bother testing for Blob since it is assumed
   *   to be the File object's prototype.
   *
   *   Will fail in Safari 5 due to its lack of support for the standards
   *   defined FileReader object
   */
  Modernizr.addTest('filereader', function () {
      return !!(window.File && window.FileList && window.FileReader);
  });
  
  
  // Detects whether input type="file" is available on the platform
  // E.g. iOS < 6 and some android version don't support this
  
  //  It's useful if you want to hide the upload feature of your app on devices that
  //  don't support it (iphone, ipad, etc).
  
  Modernizr.addTest('fileinput', function() {
      var elem = document.createElement('input');
      elem.type = 'file';
      return !elem.disabled;
  });
  // Detects whether input form="form_id" is available on the platform
  // E.g. IE 10 (and below), don't support this
  Modernizr.addTest("formattribute", function() {
  	var form = document.createElement("form"),
  		input = document.createElement("input"),
  		div = document.createElement("div"),
  		id = "formtest"+(new Date().getTime()),
  		attr,
  		bool = false;
  
  		form.id = id;
  
  	//IE6/7 confuses the form idl attribute and the form content attribute
  	if(document.createAttribute){
  		attr = document.createAttribute("form");
  		attr.nodeValue = id;
  		input.setAttributeNode(attr);
  		div.appendChild(form);
  		div.appendChild(input);
  
  		document.documentElement.appendChild(div);
  
  		bool = form.elements.length === 1 && input.form == form;
  
  		div.parentNode.removeChild(div);
  	}
  
  	return bool;
  });// Filesystem API
  // dev.w3.org/2009/dap/file-system/file-dir-sys.html
  
  // The API will be present in Chrome incognito, but will throw an exception.
  // See crbug.com/93417
  //
  // By Eric Bidelman (@ebidel)
  
  Modernizr.addTest('filesystem', !!Modernizr.prefixed('requestFileSystem', window));// testing for placeholder attribute in inputs and textareas
  // re-using Modernizr.input if available
  
  Modernizr.addTest('placeholder', function(){
  
    return !!( 'placeholder' in ( Modernizr.input    || document.createElement('input')    ) && 
               'placeholder' in ( Modernizr.textarea || document.createElement('textarea') )
             );
  
  });
  Modernizr.addTest('fullscreen',function(){
       for(var i = 0; i < Modernizr._domPrefixes.length; i++) {
          if( document[Modernizr._domPrefixes[i].toLowerCase() + 'CancelFullScreen'])
              return true;
       }
       return !!document['cancelFullScreen'] || false;
  });
  
  // http://developer.apple.com/library/safari/documentation/AudioVideo/Conceptual/Using_HTML5_Audio_Video/ControllingMediaWithJavaScript/ControllingMediaWithJavaScript.html#//apple_ref/doc/uid/TP40009523-CH3-SW20
  // https://developer.mozilla.org/en/API/Fullscreen
  // This implementation only tests support for interactive form validation.
  // To check validation for a specific type or a specific other constraint,
  // the test can be combined: 
  //    - Modernizr.inputtypes.numer && Modernizr.formvalidation (browser supports rangeOverflow, typeMismatch etc. for type=number)
  //    - Modernizr.input.required && Modernizr.formvalidation (browser supports valueMissing)
  //
  (function(document, Modernizr){
  
  
  Modernizr.formvalidationapi = false;
  Modernizr.formvalidationmessage = false;
  
  Modernizr.addTest('formvalidation', function(){
      var form = document.createElement('form');
      if ( !('checkValidity' in form) ) {
          return false;
      }
      var body = document.body,
  
      html = document.documentElement,
  
      bodyFaked = false,
  
      invaildFired = false,
  
      input;
  
      Modernizr.formvalidationapi = true;
  
      // Prevent form from being submitted
      form.onsubmit = function(e) {
          //Opera does not validate form, if submit is prevented
          if ( !window.opera ) {
              e.preventDefault();
          }
          e.stopPropagation();
      };
  
      // Calling form.submit() doesn't trigger interactive validation, 
      // use a submit button instead
      //older opera browsers need a name attribute
      form.innerHTML = '<input name="modTest" required><button></button>';
  
      // FF4 doesn't trigger "invalid" event if form is not in the DOM tree
      // Chrome throws error if invalid input is not visible when submitting 
      form.style.position = 'absolute';
      form.style.top = '-99999em';
  
      // We might in <head> in which case we need to create body manually
      if ( !body ) {
          bodyFaked = true;
          body = document.createElement('body');
          //avoid crashing IE8, if background image is used
          body.style.background = "";
          html.appendChild(body);
      }
  
      body.appendChild(form);
  
      input = form.getElementsByTagName('input')[0];	
  
      // Record whether "invalid" event is fired
      input.oninvalid = function(e) {
          invaildFired = true;
          e.preventDefault();
          e.stopPropagation();
      };
  
      //Opera does not fully support the validationMessage property
      Modernizr.formvalidationmessage = !!input.validationMessage;
  
      // Submit form by clicking submit button
      form.getElementsByTagName('button')[0].click();
  
      // Don't forget to clean up
      body.removeChild(form);
      bodyFaked && html.removeChild(body);
  
      return invaildFired;
  });
  
  
  })(document, window.Modernizr);// speech input for inputs
  // by @alrra
  
  
  // `webkitSpeech` in elem 
  // doesn`t work correctly in all versions of Chromium based browsers.
  //   It can return false even if they have support for speech i.imgur.com/2Y40n.png
  //  Testing with 'onwebkitspeechchange' seems to fix this problem
  
  // this detect only checks the webkit version because
  // the speech attribute is likely to be deprecated in favor of a JavaScript API.
  // http://lists.w3.org/Archives/Public/public-webapps/2011OctDec/att-1696/speechapi.html
  
  // FIXME: add support for detecting the new spec'd behavior
  
  Modernizr.addTest('speechinput', function(){
      var elem = document.createElement('input'); 
      return 'speech' in elem || 'onwebkitspeechchange' in elem; 
  });// GamePad API
  // https://dvcs.w3.org/hg/gamepad/raw-file/default/gamepad.html
  // By Eric Bidelman
  
  // FF has Gamepad API support only in special builds, but not in any release (even behind a flag)
  // Their current implementation has no way to feature detect, only events to bind to.
  //   http://www.html5rocks.com/en/tutorials/doodles/gamepad/#toc-featuredetect
  
  // but a patch will bring them up to date with the spec when it lands (and they'll pass this test)
  //   https://bugzilla.mozilla.org/show_bug.cgi?id=690935
  
  Modernizr.addTest('gamepads', !!Modernizr.prefixed('getGamepads', navigator));
  // getUserMedia
  // http://www.whatwg.org/specs/web-apps/current-work/multipage/video-conferencing-and-peer-to-peer-communication.html
  // By Eric Bidelman
  
  Modernizr.addTest('getusermedia', !!Modernizr.prefixed('getUserMedia', navigator));
  // IE8 compat mode aka Fake IE7
  // by Erich Ocean
  
  // In this case, IE8 will be acting as IE7. You may choose to remove features in this case.
  
  // related:
  // james.padolsey.com/javascript/detect-ie-in-js-using-conditional-comments/
  
  Modernizr.addTest('ie8compat',function(){
      return (!window.addEventListener && document.documentMode && document.documentMode === 7);
  });
  // Test for `sandbox` attribute in iframes.
  //
  // Spec: http://www.whatwg.org/specs/web-apps/current-work/multipage/the-iframe-element.html#attr-iframe-sandbox
  
  Modernizr.addTest('sandbox', 'sandbox' in document.createElement('iframe'));
  // Test for `srcdoc` attribute in iframes.
  //
  // Spec: http://www.whatwg.org/specs/web-apps/current-work/multipage/the-iframe-element.html#attr-iframe-srcdoc
  
  Modernizr.addTest('srcdoc', 'srcdoc' in document.createElement('iframe'));
  // Test for `seamless` attribute in iframes.
  //
  // Spec: http://www.whatwg.org/specs/web-apps/current-work/multipage/the-iframe-element.html#attr-iframe-seamless
  
  Modernizr.addTest('seamless', 'seamless' in document.createElement('iframe'));
  // code.google.com/speed/webp/
  // by rich bradshaw, ryan seddon, and paul irish
  
  
  // This test is asynchronous. Watch out.
  
  (function(){
  
    var image = new Image();
  
    image.onerror = function() {
        Modernizr.addTest('webp', false);
    };  
    image.onload = function() {
        Modernizr.addTest('webp', function() { return image.width == 1; });
    };
  
    image.src = 'data:image/webp;base64,UklGRiwAAABXRUJQVlA4ICAAAAAUAgCdASoBAAEAL/3+/3+CAB/AAAFzrNsAAP5QAAAAAA==';
  
  }());// Animated PNG
  // http://en.wikipedia.org/wiki/APNG
  // By Addy Osmani
  (function () {
  
      if (!Modernizr.canvas) return false;
      
      var image = new Image(),
          canvas = document.createElement('canvas'),
          ctx = canvas.getContext('2d');
  
  
      image.onload = function () {
          Modernizr.addTest('apng', function () {
              if (typeof canvas.getContext == 'undefined') {
                  return false;
              } else {
                  ctx.drawImage(image, 0, 0);
                  return ctx.getImageData(0, 0, 1, 1).data[3] === 0;
              }
          });
      };
  
      image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACGFjVEwAAAABAAAAAcMq2TYAAAANSURBVAiZY2BgYPgPAAEEAQB9ssjfAAAAGmZjVEwAAAAAAAAAAQAAAAEAAAAAAAAAAAD6A+gBAbNU+2sAAAARZmRBVAAAAAEImWNgYGBgAAAABQAB6MzFdgAAAABJRU5ErkJggg==";
  
  }());
  // native JSON support.
  // developer.mozilla.org/en/JSON
  
  // this will also succeed if you've loaded the JSON2.js polyfill ahead of time
  //   ... but that should be obvious. :)
  
  Modernizr.addTest('json', !!window.JSON && !!JSON.parse);
  
  // impressivewebs.com/reverse-ordered-lists-html5
  // polyfill: github.com/impressivewebs/HTML5-Reverse-Ordered-Lists
  
  
  Modernizr.addTest('olreversed', 'reversed' in document.createElement('ol'));
  // determining low-bandwidth via navigator.connection
  
  // There are two iterations of the navigator.connection interface:
  
  // The first is present in Android 2.2+ and only in the Browser (not WebView)
  // : docs.phonegap.com/en/1.2.0/phonegap_connection_connection.md.html#connection.type
  // : davidbcalhoun.com/2010/using-navigator-connection-android
  
  // The second is specced at dev.w3.org/2009/dap/netinfo/ and perhaps landing in WebKit
  // : bugs.webkit.org/show_bug.cgi?id=73528
  
  // unknown devices are assumed as fast
  // for more rigorous network testing, consider boomerang.js: github.com/bluesmoon/boomerang/
  
  Modernizr.addTest('lowbandwidth', function() {
  
    var connection = navigator.connection || { type: 0 }; // polyfill
  
    return connection.type == 3 || // connection.CELL_2G
        connection.type == 4 || // connection.CELL_3G
        /^[23]g$/.test(connection.type); // string value in new spec
  });
  
  
  // XML HTTP Request Level 2
  // www.w3.org/TR/XMLHttpRequest2/
  
  // Much more details at github.com/Modernizr/Modernizr/issues/385
  
  // all three of these details report consistently across all target browsers:
  //   !!(window.ProgressEvent);
  //   !!(window.FormData);
  //   window.XMLHttpRequest && "withCredentials" in new XMLHttpRequest;
  
  Modernizr.addTest('xhr2', 'FormData' in window);
  
  // server sent events aka eventsource
  // dev.w3.org/html5/eventsource/
  
  Modernizr.addTest('eventsource', !!window.EventSource);
  // Notifications
  // By Theodoor van Donge
  
  // window.webkitNotifications is only used by Chrome 
  //	http://www.html5rocks.com/en/tutorials/notifications/quick/
  
  // window.Notification only exist in the draft specs 
  //	http://dev.w3.org/2006/webapi/WebNotifications/publish/Notifications.html#idl-if-Notification
  
  Modernizr.addTest('notification', !!Modernizr.prefixed('Notifications', window));// Navigation Timing (Performance)
  // https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/
  // http://www.html5rocks.com/en/tutorials/webperformance/basics/
  // By Scott Murphy (uxder)
  Modernizr.addTest('performance', !!Modernizr.prefixed('performance', window));// https://developer.mozilla.org/en-US/docs/API/Pointer_Lock_API
  
  Modernizr.addTest('pointerlock',!!Modernizr.prefixed('pointerLockElement', document));
  
  // Quota Storage Management API
  // This API can be used to check how much quota an origin is using and request more
  
  // Currently only implemented in Chrome.
  // https://developers.google.com/chrome/whitepapers/storage
  // By Addy Osmani
  
  Modernizr.addTest('quotamanagement', function(){
    var storage = Modernizr.prefixed('StorageInfo', window);
    return !!(storage && 'TEMPORARY' in storage && 'PERSISTENT' in storage);
  });
  // async script
  // By Theodoor van Donge
  Modernizr.addTest('scriptasync', 'async' in document.createElement('script'));
  // requestAnimationFrame
  // Offload animation repainting to browser for optimized performance. 
  // http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/RequestAnimationFrame/Overview.html
  // By Addy Osmani
  
  Modernizr.addTest('raf', !!Modernizr.prefixed('requestAnimationFrame', window));// defer script
  // By Theodoor van Donge
  Modernizr.addTest('scriptdefer', 'defer' in document.createElement('script'));// Browser support test for <style scoped>
  // http://www.w3.org/TR/html5/the-style-element.html#attr-style-scoped
  //
  // by @alrra
  
  Modernizr.addTest( 'stylescoped', 'scoped' in document.createElement('style') );
  // Detect support for svg filters - http://www.w3.org/TR/SVG11/filters.html.
  // Should fail in Safari: http://stackoverflow.com/questions/9739955/feature-detecting-support-for-svg-filters.
  // detect by erik dahlstrom
  
  Modernizr.addTest('svgfilters', function(){
  	var result = false;
      try {
        result = typeof SVGFEColorMatrixElement !== undefined &&
                 SVGFEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_SATURATE == 2;
      }
      catch(e) {}
      return result;
  });
  /**
   * Unicode special character support
   * 
   * Detection is made by testing missing glyph box rendering against star character
   * If widths are the same, this "probably" means the browser didn't support the star character and rendered a glyph box instead
   * Just need to ensure the font characters have different widths
   * 
   * Warning : positive Unicode support doesn't mean you can use it inside <title>, this seams more related to OS & Language packs
   */
  Modernizr.addTest('unicode', function() {
  	
  	
  	var bool,
  
  		missingGlyph = document.createElement('span'),
  		
  		star = document.createElement('span');
  
  	Modernizr.testStyles('#modernizr{font-family:Arial,sans;font-size:300em;}', function(node) {
  
  		missingGlyph.innerHTML = '&#5987';
  		star.innerHTML = '&#9734';		
  		
  		node.appendChild(missingGlyph);
  		node.appendChild(star);
  		
  		bool = 'offsetWidth' in missingGlyph && missingGlyph.offsetWidth !== star.offsetWidth;
  	});
  
  	return bool;
  
  });// test if IE userdata supported
  // msdn.microsoft.com/en-us/library/ms531424(v=vs.85).aspx
  // test by @stereobooster
  
  Modernizr.addTest('userdata', function(){
    return !!document.createElement('div').addBehavior;
  });
  // data uri test.
  // https://github.com/Modernizr/Modernizr/issues/14
  
  // This test is asynchronous. Watch out.
  
  
  // in IE7 in HTTPS this can cause a Mixed Content security popup. 
  //  github.com/Modernizr/Modernizr/issues/362
  // To avoid that you can create a new iframe and inject this.. perhaps..
  
  
  (function(){
  
    var datauri = new Image();
  
  
    datauri.onerror = function() {
        Modernizr.addTest('datauri', function () { return false; });
    };  
    datauri.onload = function() {
        Modernizr.addTest('datauri', function () { return (datauri.width == 1 && datauri.height == 1); });
    };
  
    datauri.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
  
  })();
  // Vibration API
  // http://www.w3.org/TR/vibration/
  // https://developer.mozilla.org/en/DOM/window.navigator.mozVibrate
  Modernizr.addTest('vibrate', !!Modernizr.prefixed('vibrate', navigator));// Tests for the ability to use Web Intents (http://webintents.org).
  // By Eric Bidelman
  
  Modernizr.addTest('webintents', function() {
    return !!Modernizr.prefixed('startActivity', navigator);
  });
  
  // Grab the WebGL extensions currently supported and add to the Modernizr.webgl object
  // spec: www.khronos.org/registry/webgl/specs/latest/#5.13.14
  
  // based on code from ilmari heikkinen
  // code.google.com/p/graphics-detect/source/browse/js/detect.js
  
  
  (function(){
  
      if (!Modernizr.webgl) return;
  
      var canvas, ctx, exts;
  
      try {
          canvas  = document.createElement('canvas');
          ctx     = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
          exts    = ctx.getSupportedExtensions();
      }
      catch (e) {
          return;
      }
  
      if (ctx === undefined) {
          Modernizr.webgl = new Boolean(false);
      }
      else {
          Modernizr.webgl = new Boolean(true);
      }
  
  
      for (var i = -1, len = exts.length; ++i < len; ){
          Modernizr.webgl[exts[i]] = true;
      }
  
      // hack for addressing modernizr testsuite failures. sorry.
      if (window.TEST && TEST.audvid){
          TEST.audvid.push('webgl');
      }
  
      canvas = undefined;
  })();
  // binaryType is truthy if there is support.. returns "blob" in new-ish chrome.
  // plus.google.com/115535723976198353696/posts/ERN6zYozENV
  
  Modernizr.addTest('websocketsbinary', 
    !!(window.WebSocket && (new WebSocket('ws://.')).binaryType)
  );
  // by jussi-kalliokoski
  
  
  // This test is asynchronous. Watch out.
  
  // The test will potentially add garbage to console.
  
  (function(){
    try {
  
      // we're avoiding using Modernizr._domPrefixes as the prefix capitalization on
      // these guys are notoriously peculiar.
      var BlobBuilder = window.MozBlobBuilder || window.WebKitBlobBuilder || window.MSBlobBuilder || window.OBlobBuilder || window.BlobBuilder,
          URL         = window.MozURL || window.webkitURL || window.MSURL || window.OURL || window.URL;
  
      var data    = 'Modernizr',
          bb      = new BlobBuilder();
  
      bb.append('this.onmessage=function(e){postMessage(e.data)}');
  
      var url     = URL.createObjectURL(bb.getBlob()),
          worker  = new Worker(url);
  
      bb = null;
  
      worker.onmessage = function(e) {
        worker.terminate();
        URL.revokeObjectURL(url);
        Modernizr.addTest('blobworkers', data === e.data);
        worker = null;
      };
  
      // Just in case...
      worker.onerror = function() {
        Modernizr.addTest('blobworkers', false);
        worker = null;
      };
  
      setTimeout(function() {
          Modernizr.addTest('blobworkers', false);
      }, 200);
  
      worker.postMessage(data);
  
    } catch (e) {
      Modernizr.addTest('blobworkers', false);
    }
  }());
  
  // tests if page is iframed
  
  // github.com/Modernizr/Modernizr/issues/242
  
  Modernizr.addTest('framed', function(){
    return window.location != top.location;
  });
  // by jussi-kalliokoski
  
  
  // This test is asynchronous. Watch out.
  
  // The test will potentially add garbage to console.
  
  (function(){
    try {
      var data    = 'Modernizr',
          worker  = new Worker('data:text/javascript;base64,dGhpcy5vbm1lc3NhZ2U9ZnVuY3Rpb24oZSl7cG9zdE1lc3NhZ2UoZS5kYXRhKX0=');
  
      worker.onmessage = function(e) {
        worker.terminate();
        Modernizr.addTest('dataworkers', data === e.data);
        worker = null;
      };
  
      // Just in case...
      worker.onerror = function() {
        Modernizr.addTest('dataworkers', false);
        worker = null;
      };
  
      setTimeout(function() {
          Modernizr.addTest('dataworkers', false);
      }, 200);
  
      worker.postMessage(data);
  
    } catch (e) {
      Modernizr.addTest('dataworkers', false);
    }
  }());
  Modernizr.addTest('sharedworkers', function(){
    return !!window.SharedWorker;
  });;