less 2.3.3 → 2.4.0

data/lib/less/js/lib/less/extend-visitor.js

@@ -0,0 +1,391 @@
+(function (tree) {
+    tree.extendFinderVisitor = function() {
+        this._visitor = new tree.visitor(this);
+        this.contexts = [];
+        this.allExtendsStack = [[]];
+    };
+
+    tree.extendFinderVisitor.prototype = {
+        run: function (root) {
+            root = this._visitor.visit(root);
+            root.allExtends = this.allExtendsStack[0];
+            return root;
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitRuleset: function (rulesetNode, visitArgs) {
+
+            if (rulesetNode.root) {
+                return;
+            }
+
+            var i, j, extend, allSelectorsExtendList = [], extendList;
+
+            // get &:extend(.a); rules which apply to all selectors in this ruleset
+            for(i = 0; i < rulesetNode.rules.length; i++) {
+                if (rulesetNode.rules[i] instanceof tree.Extend) {
+                    allSelectorsExtendList.push(rulesetNode.rules[i]);
+                }
+            }
+
+            // now find every selector and apply the extends that apply to all extends
+            // and the ones which apply to an individual extend
+            for(i = 0; i < rulesetNode.paths.length; i++) {
+                var selectorPath = rulesetNode.paths[i],
+                    selector = selectorPath[selectorPath.length-1];
+                extendList = selector.extendList.slice(0).concat(allSelectorsExtendList).map(function(allSelectorsExtend) {
+                    return allSelectorsExtend.clone();
+                });
+                for(j = 0; j < extendList.length; j++) {
+                    this.foundExtends = true;
+                    extend = extendList[j];
+                    extend.findSelfSelectors(selectorPath);
+                    extend.ruleset = rulesetNode;
+                    if (j === 0) { extend.firstExtendOnThisSelectorPath = true; }
+                    this.allExtendsStack[this.allExtendsStack.length-1].push(extend);
+                }
+            }
+
+            this.contexts.push(rulesetNode.selectors);
+        },
+        visitRulesetOut: function (rulesetNode) {
+            if (!rulesetNode.root) {
+                this.contexts.length = this.contexts.length - 1;
+            }
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            mediaNode.allExtends = [];
+            this.allExtendsStack.push(mediaNode.allExtends);
+        },
+        visitMediaOut: function (mediaNode) {
+            this.allExtendsStack.length = this.allExtendsStack.length - 1;
+        },
+        visitDirective: function (directiveNode, visitArgs) {
+            directiveNode.allExtends = [];
+            this.allExtendsStack.push(directiveNode.allExtends);
+        },
+        visitDirectiveOut: function (directiveNode) {
+            this.allExtendsStack.length = this.allExtendsStack.length - 1;
+        }
+    };
+
+    tree.processExtendsVisitor = function() {
+        this._visitor = new tree.visitor(this);
+    };
+
+    tree.processExtendsVisitor.prototype = {
+        run: function(root) {
+            var extendFinder = new tree.extendFinderVisitor();
+            extendFinder.run(root);
+            if (!extendFinder.foundExtends) { return root; }
+            root.allExtends = root.allExtends.concat(this.doExtendChaining(root.allExtends, root.allExtends));
+            this.allExtendsStack = [root.allExtends];
+            return this._visitor.visit(root);
+        },
+        doExtendChaining: function (extendsList, extendsListTarget, iterationCount) {
+            //
+            // chaining is different from normal extension.. if we extend an extend then we are not just copying, altering and pasting
+            // the selector we would do normally, but we are also adding an extend with the same target selector
+            // this means this new extend can then go and alter other extends
+            //
+            // this method deals with all the chaining work - without it, extend is flat and doesn't work on other extend selectors
+            // this is also the most expensive.. and a match on one selector can cause an extension of a selector we had already processed if
+            // we look at each selector at a time, as is done in visitRuleset
+
+            var extendIndex, targetExtendIndex, matches, extendsToAdd = [], newSelector, extendVisitor = this, selectorPath, extend, targetExtend, newExtend;
+
+            iterationCount = iterationCount || 0;
+
+            //loop through comparing every extend with every target extend.
+            // a target extend is the one on the ruleset we are looking at copy/edit/pasting in place
+            // e.g.  .a:extend(.b) {}  and .b:extend(.c) {} then the first extend extends the second one
+            // and the second is the target.
+            // the seperation into two lists allows us to process a subset of chains with a bigger set, as is the
+            // case when processing media queries
+            for(extendIndex = 0; extendIndex < extendsList.length; extendIndex++){
+                for(targetExtendIndex = 0; targetExtendIndex < extendsListTarget.length; targetExtendIndex++){
+
+                    extend = extendsList[extendIndex];
+                    targetExtend = extendsListTarget[targetExtendIndex];
+
+                    // look for circular references
+                    if (this.inInheritanceChain(targetExtend, extend)) { continue; }
+
+                    // find a match in the target extends self selector (the bit before :extend)
+                    selectorPath = [targetExtend.selfSelectors[0]];
+                    matches = extendVisitor.findMatch(extend, selectorPath);
+
+                    if (matches.length) {
+
+                        // we found a match, so for each self selector..
+                        extend.selfSelectors.forEach(function(selfSelector) {
+
+                            // process the extend as usual
+                            newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector);
+
+                            // but now we create a new extend from it
+                            newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0);
+                            newExtend.selfSelectors = newSelector;
+
+                            // add the extend onto the list of extends for that selector
+                            newSelector[newSelector.length-1].extendList = [newExtend];
+
+                            // record that we need to add it.
+                            extendsToAdd.push(newExtend);
+                            newExtend.ruleset = targetExtend.ruleset;
+
+                            //remember its parents for circular references
+                            newExtend.parents = [targetExtend, extend];
+
+                            // only process the selector once.. if we have :extend(.a,.b) then multiple
+                            // extends will look at the same selector path, so when extending
+                            // we know that any others will be duplicates in terms of what is added to the css
+                            if (targetExtend.firstExtendOnThisSelectorPath) {
+                                newExtend.firstExtendOnThisSelectorPath = true;
+                                targetExtend.ruleset.paths.push(newSelector);
+                            }
+                        });
+                    }
+                }
+            }
+
+            if (extendsToAdd.length) {
+                // try to detect circular references to stop a stack overflow.
+                // may no longer be needed.
+                this.extendChainCount++;
+                if (iterationCount > 100) {
+                    var selectorOne = "{unable to calculate}";
+                    var selectorTwo = "{unable to calculate}";
+                    try
+                    {
+                        selectorOne = extendsToAdd[0].selfSelectors[0].toCSS();
+                        selectorTwo = extendsToAdd[0].selector.toCSS();
+                    }
+                    catch(e) {}
+                    throw {message: "extend circular reference detected. One of the circular extends is currently:"+selectorOne+":extend(" + selectorTwo+")"};
+                }
+
+                // now process the new extends on the existing rules so that we can handle a extending b extending c ectending d extending e...
+                return extendsToAdd.concat(extendVisitor.doExtendChaining(extendsToAdd, extendsListTarget, iterationCount+1));
+            } else {
+                return extendsToAdd;
+            }
+        },
+        inInheritanceChain: function (possibleParent, possibleChild) {
+            if (possibleParent === possibleChild) {
+                return true;
+            }
+            if (possibleChild.parents) {
+                if (this.inInheritanceChain(possibleParent, possibleChild.parents[0])) {
+                    return true;
+                }
+                if (this.inInheritanceChain(possibleParent, possibleChild.parents[1])) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitSelector: function (selectorNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitRuleset: function (rulesetNode, visitArgs) {
+            if (rulesetNode.root) {
+                return;
+            }
+            var matches, pathIndex, extendIndex, allExtends = this.allExtendsStack[this.allExtendsStack.length-1], selectorsToAdd = [], extendVisitor = this, selectorPath;
+
+            // look at each selector path in the ruleset, find any extend matches and then copy, find and replace
+
+            for(extendIndex = 0; extendIndex < allExtends.length; extendIndex++) {
+                for(pathIndex = 0; pathIndex < rulesetNode.paths.length; pathIndex++) {
+
+                    selectorPath = rulesetNode.paths[pathIndex];
+
+                    // extending extends happens initially, before the main pass
+                    if (selectorPath[selectorPath.length-1].extendList.length) { continue; }
+
+                    matches = this.findMatch(allExtends[extendIndex], selectorPath);
+
+                    if (matches.length) {
+
+                        allExtends[extendIndex].selfSelectors.forEach(function(selfSelector) {
+                            selectorsToAdd.push(extendVisitor.extendSelector(matches, selectorPath, selfSelector));
+                        });
+                    }
+                }
+            }
+            rulesetNode.paths = rulesetNode.paths.concat(selectorsToAdd);
+        },
+        findMatch: function (extend, haystackSelectorPath) {
+            //
+            // look through the haystack selector path to try and find the needle - extend.selector
+            // returns an array of selector matches that can then be replaced
+            //
+            var haystackSelectorIndex, hackstackSelector, hackstackElementIndex, haystackElement,
+                targetCombinator, i,
+                extendVisitor = this,
+                needleElements = extend.selector.elements,
+                potentialMatches = [], potentialMatch, matches = [];
+
+            // loop through the haystack elements
+            for(haystackSelectorIndex = 0; haystackSelectorIndex < haystackSelectorPath.length; haystackSelectorIndex++) {
+                hackstackSelector = haystackSelectorPath[haystackSelectorIndex];
+
+                for(hackstackElementIndex = 0; hackstackElementIndex < hackstackSelector.elements.length; hackstackElementIndex++) {
+
+                    haystackElement = hackstackSelector.elements[hackstackElementIndex];
+
+                    // if we allow elements before our match we can add a potential match every time. otherwise only at the first element.
+                    if (extend.allowBefore || (haystackSelectorIndex == 0 && hackstackElementIndex == 0)) {
+                        potentialMatches.push({pathIndex: haystackSelectorIndex, index: hackstackElementIndex, matched: 0, initialCombinator: haystackElement.combinator});
+                    }
+
+                    for(i = 0; i < potentialMatches.length; i++) {
+                        potentialMatch = potentialMatches[i];
+
+                        // selectors add " " onto the first element. When we use & it joins the selectors together, but if we don't
+                        // then each selector in haystackSelectorPath has a space before it added in the toCSS phase. so we need to work out
+                        // what the resulting combinator will be
+                        targetCombinator = haystackElement.combinator.value;
+                        if (targetCombinator == '' && hackstackElementIndex === 0) {
+                            targetCombinator = ' ';
+                        }
+
+                        // if we don't match, null our match to indicate failure
+                        if (!extendVisitor.isElementValuesEqual(needleElements[potentialMatch.matched].value, haystackElement.value) ||
+                            (potentialMatch.matched > 0 && needleElements[potentialMatch.matched].combinator.value !== targetCombinator)) {
+                            potentialMatch = null;
+                        } else {
+                            potentialMatch.matched++;
+                        }
+
+                        // if we are still valid and have finished, test whether we have elements after and whether these are allowed
+                        if (potentialMatch) {
+                            potentialMatch.finished = potentialMatch.matched === needleElements.length;
+                            if (potentialMatch.finished &&
+                                (!extend.allowAfter && (hackstackElementIndex+1 < hackstackSelector.elements.length || haystackSelectorIndex+1 < haystackSelectorPath.length))) {
+                                potentialMatch = null;
+                            }
+                        }
+                        // if null we remove, if not, we are still valid, so either push as a valid match or continue
+                        if (potentialMatch) {
+                            if (potentialMatch.finished) {
+                                potentialMatch.length = needleElements.length;
+                                potentialMatch.endPathIndex = haystackSelectorIndex;
+                                potentialMatch.endPathElementIndex = hackstackElementIndex + 1; // index after end of match
+                                potentialMatches.length = 0; // we don't allow matches to overlap, so start matching again
+                                matches.push(potentialMatch);
+                            }
+                        } else {
+                            potentialMatches.splice(i, 1);
+                            i--;
+                        }
+                    }
+                }
+            }
+            return matches;
+        },
+        isElementValuesEqual: function(elementValue1, elementValue2) {
+            if (typeof elementValue1 === "string" || typeof elementValue2 === "string") {
+                return elementValue1 === elementValue2;
+            }
+            if (elementValue1 instanceof tree.Attribute) {
+                if (elementValue1.op !== elementValue2.op || elementValue1.key !== elementValue2.key) {
+                    return false;
+                }
+                if (!elementValue1.value || !elementValue2.value) {
+                    if (elementValue1.value || elementValue2.value) {
+                        return false;
+                    }
+                    return true;
+                }
+                elementValue1 = elementValue1.value.value || elementValue1.value;
+                elementValue2 = elementValue2.value.value || elementValue2.value;
+                return elementValue1 === elementValue2;
+            }
+            return false;
+        },
+        extendSelector:function (matches, selectorPath, replacementSelector) {
+
+            //for a set of matches, replace each match with the replacement selector
+
+            var currentSelectorPathIndex = 0,
+                currentSelectorPathElementIndex = 0,
+                path = [],
+                matchIndex,
+                selector,
+                firstElement,
+                match;
+
+            for (matchIndex = 0; matchIndex < matches.length; matchIndex++) {
+                match = matches[matchIndex];
+                selector = selectorPath[match.pathIndex];
+                firstElement = new tree.Element(
+                    match.initialCombinator,
+                    replacementSelector.elements[0].value,
+                    replacementSelector.elements[0].index
+                );
+
+                if (match.pathIndex > currentSelectorPathIndex && currentSelectorPathElementIndex > 0) {
+                    path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
+                    currentSelectorPathElementIndex = 0;
+                    currentSelectorPathIndex++;
+                }
+
+                path = path.concat(selectorPath.slice(currentSelectorPathIndex, match.pathIndex));
+
+                path.push(new tree.Selector(
+                    selector.elements
+                        .slice(currentSelectorPathElementIndex, match.index)
+                        .concat([firstElement])
+                        .concat(replacementSelector.elements.slice(1))
+                ));
+                currentSelectorPathIndex = match.endPathIndex;
+                currentSelectorPathElementIndex = match.endPathElementIndex;
+                if (currentSelectorPathElementIndex >= selector.elements.length) {
+                    currentSelectorPathElementIndex = 0;
+                    currentSelectorPathIndex++;
+                }
+            }
+
+            if (currentSelectorPathIndex < selectorPath.length && currentSelectorPathElementIndex > 0) {
+                path[path.length - 1].elements = path[path.length - 1].elements.concat(selectorPath[currentSelectorPathIndex].elements.slice(currentSelectorPathElementIndex));
+                currentSelectorPathElementIndex = 0;
+                currentSelectorPathIndex++;
+            }
+
+            path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
+
+            return path;
+        },
+        visitRulesetOut: function (rulesetNode) {
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
+            newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));
+            this.allExtendsStack.push(newAllExtends);
+        },
+        visitMediaOut: function (mediaNode) {
+            this.allExtendsStack.length = this.allExtendsStack.length - 1;
+        },
+        visitDirective: function (directiveNode, visitArgs) {
+            var newAllExtends = directiveNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length-1]);
+            newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, directiveNode.allExtends));
+            this.allExtendsStack.push(newAllExtends);
+        },
+        visitDirectiveOut: function (directiveNode) {
+            this.allExtendsStack.length = this.allExtendsStack.length - 1;
+        }
+    };
+
+})(require('./tree'));

data/lib/less/js/lib/less/functions.js

@@ -14,7 +14,7 @@ tree.functions = {
     },
     hsla: function (h, s, l, a) {
         h = (number(h) % 360) / 360;
-        s = number(s); l = number(l); a = number(a);
+        s = clamp(number(s)); l = clamp(number(l)); a = clamp(number(a));
 
         var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
         var m1 = l * 2 - m2;
@@ -71,6 +71,15 @@ tree.functions = {
     lightness: function (color) {
         return new(tree.Dimension)(Math.round(color.toHSL().l * 100), '%');
     },
+    hsvhue: function(color) {
+        return new(tree.Dimension)(Math.round(color.toHSV().h));
+    },
+    hsvsaturation: function (color) {
+        return new(tree.Dimension)(Math.round(color.toHSV().s * 100), '%');
+    },
+    hsvvalue: function (color) {
+        return new(tree.Dimension)(Math.round(color.toHSV().v * 100), '%');
+    },
     red: function (color) {
         return new(tree.Dimension)(color.rgb[0]);
     },
@@ -84,10 +93,7 @@ tree.functions = {
         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), '%');
+        return new(tree.Dimension)(Math.round(color.luma() * color.alpha * 100), '%');
     },
     saturate: function (color, amount) {
         var hsl = color.toHSL();
@@ -184,12 +190,18 @@ tree.functions = {
         if (typeof dark === 'undefined') {
             dark = this.rgba(0, 0, 0, 1.0);
         }
+        //Figure out which is actually light and dark!
+        if (dark.luma() > light.luma()) {
+            var t = light;
+            light = dark;
+            dark = t;
+        }
         if (typeof threshold === 'undefined') {
             threshold = 0.43;
         } else {
-            threshold = threshold.value;
+            threshold = number(threshold);
         }
-        if (((0.2126 * (color.rgb[0]/255) + 0.7152 * (color.rgb[1]/255) + 0.0722 * (color.rgb[2]/255)) * color.alpha) < threshold) {
+        if ((color.luma() * color.alpha) < threshold) {
             return light;
         } else {
             return dark;
@@ -217,19 +229,32 @@ tree.functions = {
     unit: function (val, unit) {
         return new(tree.Dimension)(val.value, unit ? unit.toCSS() : "");
     },
+    convert: function (val, unit) {
+        return val.convertTo(unit.value);
+    },
     round: function (n, f) {
         var fraction = typeof(f) === "undefined" ? 0 : f.value;
-        return this._math(function(num) { return num.toFixed(fraction); }, n);
+        return this._math(function(num) { return num.toFixed(fraction); }, null, n);
+    },
+    pi: function () {
+        return new(tree.Dimension)(Math.PI);
     },
-    ceil: function (n) {
-        return this._math(Math.ceil, n);
+    mod: function(a, b) {
+        return new(tree.Dimension)(a.value % b.value, a.unit);
     },
-    floor: function (n) {
-        return this._math(Math.floor, n);
+    pow: function(x, y) {
+        if (typeof x === "number" && typeof y === "number") {
+            x = new(tree.Dimension)(x);
+            y = new(tree.Dimension)(y);
+        } else if (!(x instanceof tree.Dimension) || !(y instanceof tree.Dimension)) {
+            throw { type: "Argument", message: "arguments must be numbers" };
+        }
+
+        return new(tree.Dimension)(Math.pow(x.value, y.value), x.unit);
     },
-    _math: function (fn, n) {
+    _math: function (fn, unit, n) {
         if (n instanceof tree.Dimension) {
-            return new(tree.Dimension)(fn(parseFloat(n.value)), n.unit);
+            return new(tree.Dimension)(fn(parseFloat(n.value)), unit == null ? n.unit : unit);
         } else if (typeof(n) === 'number') {
             return fn(n);
         } else {
@@ -266,13 +291,16 @@ tree.functions = {
         return this._isa(n, tree.URL);
     },
     ispixel: function (n) {
-        return (n instanceof tree.Dimension) && n.unit === 'px' ? tree.True : tree.False;
+        return this.isunit(n, 'px');
     },
     ispercentage: function (n) {
-        return (n instanceof tree.Dimension) && n.unit === '%' ? tree.True : tree.False;
+        return this.isunit(n, '%');
     },
     isem: function (n) {
-        return (n instanceof tree.Dimension) && n.unit === 'em' ? tree.True : tree.False;
+        return this.isunit(n, 'em');
+    },
+    isunit: function (n, unit) {
+        return (n instanceof tree.Dimension) && n.unit.is(unit.value || unit) ? tree.True : tree.False;
     },
     _isa: function (n, Type) {
         return (n instanceof Type) ? tree.True : tree.False;
@@ -342,15 +370,135 @@ tree.functions = {
     },
     shade: function(color, amount) {
         return this.mix(this.rgb(0, 0, 0), color, amount);
+    },
+    extract: function(values, index) {
+        index = index.value - 1; // (1-based index)
+        return values.value[index];
+    },
+
+    "data-uri": function(mimetypeNode, filePathNode) {
+
+        if (typeof window !== 'undefined') {
+            return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
+        }
+
+        var mimetype = mimetypeNode.value;
+        var filePath = (filePathNode && filePathNode.value);
+
+        var fs = require("fs"),
+            path = require("path"),
+            useBase64 = false;
+
+        if (arguments.length < 2) {
+            filePath = mimetype;
+        }
+
+        if (this.env.isPathRelative(filePath)) {
+            if (this.currentFileInfo.relativeUrls) {
+                filePath = path.join(this.currentFileInfo.currentDirectory, filePath);
+            } else {
+                filePath = path.join(this.currentFileInfo.entryPath, filePath);
+            }
+        }
+
+        // detect the mimetype if not given
+        if (arguments.length < 2) {
+            var mime;
+            try {
+                mime = require('mime');
+            } catch (ex) {
+                mime = tree._mime;
+            }
+
+            mimetype = mime.lookup(filePath);
+
+            // use base 64 unless it's an ASCII or UTF-8 format
+            var charset = mime.charsets.lookup(mimetype);
+            useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0;
+            if (useBase64) mimetype += ';base64';
+        }
+        else {
+            useBase64 = /;base64$/.test(mimetype)
+        }
+
+        var buf = fs.readFileSync(filePath);
+
+        // IE8 cannot handle a data-uri larger than 32KB. If this is exceeded
+        // and the --ieCompat flag is enabled, return a normal url() instead.
+        var DATA_URI_MAX_KB = 32,
+            fileSizeInKB = parseInt((buf.length / 1024), 10);
+        if (fileSizeInKB >= DATA_URI_MAX_KB) {
+
+            if (this.env.ieCompat !== false) {
+                if (!this.env.silent) {
+                    console.warn("Skipped data-uri embedding of %s because its size (%dKB) exceeds IE8-safe %dKB!", filePath, fileSizeInKB, DATA_URI_MAX_KB);
+                }
+
+                return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
+            } else if (!this.env.silent) {
+                // if explicitly disabled (via --no-ie-compat on CLI, or env.ieCompat === false), merely warn
+                console.warn("WARNING: Embedding %s (%dKB) exceeds IE8's data-uri size limit of %dKB!", filePath, fileSizeInKB, DATA_URI_MAX_KB);
+            }
+        }
+
+        buf = useBase64 ? buf.toString('base64')
+                        : encodeURIComponent(buf);
+
+        var uri = "'data:" + mimetype + ',' + buf + "'";
+        return new(tree.URL)(new(tree.Anonymous)(uri));
+    }
+};
+
+// these static methods are used as a fallback when the optional 'mime' dependency is missing
+tree._mime = {
+    // this map is intentionally incomplete
+    // if you want more, install 'mime' dep
+    _types: {
+        '.htm' : 'text/html',
+        '.html': 'text/html',
+        '.gif' : 'image/gif',
+        '.jpg' : 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png' : 'image/png'
+    },
+    lookup: function (filepath) {
+        var ext = require('path').extname(filepath),
+            type = tree._mime._types[ext];
+        if (type === undefined) {
+            throw new Error('Optional dependency "mime" is required for ' + ext);
+        }
+        return type;
+    },
+    charsets: {
+        lookup: function (type) {
+            // assumes all text types are UTF-8
+            return type && (/^text\//).test(type) ? 'UTF-8' : '';
+        }
     }
 };
 
+var mathFunctions = [{name:"ceil"}, {name:"floor"}, {name: "sqrt"}, {name:"abs"},
+        {name:"tan", unit: ""}, {name:"sin", unit: ""}, {name:"cos", unit: ""},
+        {name:"atan", unit: "rad"}, {name:"asin", unit: "rad"}, {name:"acos", unit: "rad"}],
+    createMathFunction = function(name, unit) {
+        return function(n) {
+            if (unit != null) {
+                n = n.unify();
+            }
+            return this._math(Math[name], unit, n);
+        };
+    };
+
+for(var i = 0; i < mathFunctions.length; i++) {
+    tree.functions[mathFunctions[i].name] = createMathFunction(mathFunctions[i].name, mathFunctions[i].unit);
+}
+
 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 == '%') {
+    if (n instanceof tree.Dimension && n.unit.is('%')) {
         return parseFloat(n.value * size / 100);
     } else {
         return number(n);
@@ -359,7 +507,7 @@ function scaled(n, size) {
 
 function number(n) {
     if (n instanceof tree.Dimension) {
-        return parseFloat(n.unit == '%' ? n.value / 100 : n.value);
+        return parseFloat(n.unit.is('%') ? n.value / 100 : n.value);
     } else if (typeof(n) === 'number') {
         return n;
     } else {
@@ -374,4 +522,11 @@ function clamp(val) {
     return Math.min(1, Math.max(0, val));
 }
 
+tree.functionCall = function(env, currentFileInfo) {
+    this.env = env;
+    this.currentFileInfo = currentFileInfo;
+};
+
+tree.functionCall.prototype = tree.functions;
+
 })(require('./tree'));