Initial commit

node_modules/autoprefixer/lib/declaration.js

@@ -0,0 +1,162 @@
+(function() {
+  var Browsers, Declaration, Prefixer, utils,
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  Prefixer = require('./prefixer');
+
+  Browsers = require('./browsers');
+
+  utils = require('./utils');
+
+  Declaration = (function(superClass) {
+    extend(Declaration, superClass);
+
+    function Declaration() {
+      return Declaration.__super__.constructor.apply(this, arguments);
+    }
+
+    Declaration.prototype.check = function(decl) {
+      return true;
+    };
+
+    Declaration.prototype.prefixed = function(prop, prefix) {
+      return prefix + prop;
+    };
+
+    Declaration.prototype.normalize = function(prop) {
+      return prop;
+    };
+
+    Declaration.prototype.otherPrefixes = function(value, prefix) {
+      var j, len, other, ref;
+      ref = Browsers.prefixes();
+      for (j = 0, len = ref.length; j < len; j++) {
+        other = ref[j];
+        if (other === prefix) {
+          continue;
+        }
+        if (value.indexOf(other) !== -1) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    Declaration.prototype.set = function(decl, prefix) {
+      decl.prop = this.prefixed(decl.prop, prefix);
+      return decl;
+    };
+
+    Declaration.prototype.needCascade = function(decl) {
+      return decl._autoprefixerCascade || (decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1);
+    };
+
+    Declaration.prototype.maxPrefixed = function(prefixes, decl) {
+      var j, len, max, prefix;
+      if (decl._autoprefixerMax) {
+        return decl._autoprefixerMax;
+      }
+      max = 0;
+      for (j = 0, len = prefixes.length; j < len; j++) {
+        prefix = prefixes[j];
+        prefix = utils.removeNote(prefix);
+        if (prefix.length > max) {
+          max = prefix.length;
+        }
+      }
+      return decl._autoprefixerMax = max;
+    };
+
+    Declaration.prototype.calcBefore = function(prefixes, decl, prefix) {
+      var before, diff, i, j, max, ref;
+      if (prefix == null) {
+        prefix = '';
+      }
+      before = decl.raw('before');
+      max = this.maxPrefixed(prefixes, decl);
+      diff = max - utils.removeNote(prefix).length;
+      for (i = j = 0, ref = diff; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
+        before += ' ';
+      }
+      return before;
+    };
+
+    Declaration.prototype.restoreBefore = function(decl) {
+      var lines, min;
+      lines = decl.raw('before').split("\n");
+      min = lines[lines.length - 1];
+      this.all.group(decl).up(function(prefixed) {
+        var array, last;
+        array = prefixed.raw('before').split("\n");
+        last = array[array.length - 1];
+        if (last.length < min.length) {
+          return min = last;
+        }
+      });
+      lines[lines.length - 1] = min;
+      return decl.raws.before = lines.join("\n");
+    };
+
+    Declaration.prototype.insert = function(decl, prefix, prefixes) {
+      var already, cloned;
+      cloned = this.set(this.clone(decl), prefix);
+      if (!cloned) {
+        return;
+      }
+      already = decl.parent.some(function(i) {
+        return i.prop === cloned.prop && i.value === cloned.value;
+      });
+      if (already) {
+        return;
+      }
+      if (this.needCascade(decl)) {
+        cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+      }
+      return decl.parent.insertBefore(decl, cloned);
+    };
+
+    Declaration.prototype.isAlready = function(decl, prefixed) {
+      var already;
+      already = this.all.group(decl).up(function(i) {
+        return i.prop === prefixed;
+      });
+      already || (already = this.all.group(decl).down(function(i) {
+        return i.prop === prefixed;
+      }));
+      return already;
+    };
+
+    Declaration.prototype.add = function(decl, prefix, prefixes) {
+      var prefixed;
+      prefixed = this.prefixed(decl.prop, prefix);
+      if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
+        return;
+      }
+      return this.insert(decl, prefix, prefixes);
+    };
+
+    Declaration.prototype.process = function(decl) {
+      var prefixes;
+      if (this.needCascade(decl)) {
+        prefixes = Declaration.__super__.process.apply(this, arguments);
+        if (prefixes != null ? prefixes.length : void 0) {
+          this.restoreBefore(decl);
+          return decl.raws.before = this.calcBefore(prefixes, decl);
+        }
+      } else {
+        return Declaration.__super__.process.apply(this, arguments);
+      }
+    };
+
+    Declaration.prototype.old = function(prop, prefix) {
+      return [this.prefixed(prop, prefix)];
+    };
+
+    return Declaration;
+
+  })(Prefixer);
+
+  module.exports = Declaration;
+
+}).call(this);