163 lines
4.8 KiB
JavaScript
163 lines
4.8 KiB
JavaScript
(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);
|