less 3.10.0-beta.2 → 3.10.3

package/lib/less/constants.js

@@ -0,0 +1,13 @@
+
+export const Math = {
+    ALWAYS: 0,
+    PARENS_DIVISION: 1,
+    PARENS: 2,
+    STRICT_LEGACY: 3
+};
+
+export const RewriteUrls = {
+    OFF: 0,
+    LOCAL: 1,
+    ALL: 2
+};

package/lib/less/contexts.js

@@ -0,0 +1,164 @@
+const contexts = {};
+export default contexts;
+import * as Constants from './constants';
+
+const copyFromOriginal = function copyFromOriginal(original, destination, propertiesToCopy) {
+    if (!original) { return; }
+
+    for (let i = 0; i < propertiesToCopy.length; i++) {
+        if (original.hasOwnProperty(propertiesToCopy[i])) {
+            destination[propertiesToCopy[i]] = original[propertiesToCopy[i]];
+        }
+    }
+};
+
+/*
+ parse is used whilst parsing
+ */
+const parseCopyProperties = [
+    // options
+    'paths',            // option - unmodified - paths to search for imports on
+    'rewriteUrls',      // option - whether to adjust URL's to be relative
+    'rootpath',         // option - rootpath to append to URL's
+    'strictImports',    // option -
+    'insecure',         // option - whether to allow imports from insecure ssl hosts
+    'dumpLineNumbers',  // option - whether to dump line numbers
+    'compress',         // option - whether to compress
+    'syncImport',       // option - whether to import synchronously
+    'chunkInput',       // option - whether to chunk input. more performant but causes parse issues.
+    'mime',             // browser only - mime type for sheet import
+    'useFileCache',     // browser only - whether to use the per file session cache
+    // context
+    'processImports',   // option & context - whether to process imports. if false then imports will not be imported.
+    // Used by the import manager to stop multiple import visitors being created.
+    'pluginManager'     // Used as the plugin manager for the session
+];
+
+contexts.Parse = function(options) {
+    copyFromOriginal(options, this, parseCopyProperties);
+
+    if (typeof this.paths === 'string') { this.paths = [this.paths]; }
+};
+
+const evalCopyProperties = [
+    'paths',             // additional include paths
+    'compress',          // whether to compress
+    'math',              // whether math has to be within parenthesis
+    'strictUnits',       // whether units need to evaluate correctly
+    'sourceMap',         // whether to output a source map
+    'importMultiple',    // whether we are currently importing multiple copies
+    'urlArgs',           // whether to add args into url tokens
+    'javascriptEnabled', // option - whether Inline JavaScript is enabled. if undefined, defaults to false
+    'pluginManager',     // Used as the plugin manager for the session
+    'importantScope',    // used to bubble up !important statements
+    'rewriteUrls'        // option - whether to adjust URL's to be relative
+];
+
+function isPathRelative(path) {
+    return !/^(?:[a-z-]+:|\/|#)/i.test(path);
+}
+
+function isPathLocalRelative(path) {
+    return path.charAt(0) === '.';
+}
+
+contexts.Eval = class {
+    constructor(options, frames) {
+        copyFromOriginal(options, this, evalCopyProperties);
+
+        if (typeof this.paths === 'string') { this.paths = [this.paths]; }
+
+        this.frames = frames || [];
+        this.importantScope = this.importantScope || [];
+        this.inCalc = false;
+        this.mathOn = true;
+    }
+
+    enterCalc() {
+        if (!this.calcStack) {
+            this.calcStack = [];
+        }
+        this.calcStack.push(true);
+        this.inCalc = true;
+    }
+
+    exitCalc() {
+        this.calcStack.pop();
+        if (!this.calcStack) {
+            this.inCalc = false;
+        }
+    }
+
+    inParenthesis() {
+        if (!this.parensStack) {
+            this.parensStack = [];
+        }
+        this.parensStack.push(true);
+    };
+
+    outOfParenthesis() {
+        this.parensStack.pop();
+    };
+
+    isMathOn(op) {
+        if (!this.mathOn) {
+            return false;
+        }
+        if (op === '/' && this.math !== Constants.Math.ALWAYS && (!this.parensStack || !this.parensStack.length)) {
+            return false;
+        }
+        if (this.math > Constants.Math.PARENS_DIVISION) {
+            return this.parensStack && this.parensStack.length;
+        }
+        return true;
+    }
+
+    pathRequiresRewrite(path) {
+        const isRelative = this.rewriteUrls === Constants.RewriteUrls.LOCAL ? isPathLocalRelative : isPathRelative;
+
+        return isRelative(path);
+    }
+
+    rewritePath(path, rootpath) {
+        let newPath;
+
+        rootpath = rootpath || '';
+        newPath = this.normalizePath(rootpath + path);
+
+        // If a path was explicit relative and the rootpath was not an absolute path
+        // we must ensure that the new path is also explicit relative.
+        if (isPathLocalRelative(path) &&
+            isPathRelative(rootpath) &&
+            isPathLocalRelative(newPath) === false) {
+            newPath = `./${newPath}`;
+        }
+
+        return newPath;
+    }
+
+    normalizePath(path) {
+        const segments = path.split('/').reverse();
+        let segment;
+
+        path = [];
+        while (segments.length !== 0) {
+            segment = segments.pop();
+            switch ( segment ) {
+                case '.':
+                    break;
+                case '..':
+                    if ((path.length === 0) || (path[path.length - 1] === '..')) {
+                        path.push( segment );
+                    } else {
+                        path.pop();
+                    }
+                    break;
+                default:
+                    path.push(segment);
+                    break;
+            }
+        }
+
+        return path.join('/');
+    }
+}

package/lib/less/data/colors.js

@@ -0,0 +1,150 @@
+export default {
+    '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',
+    'rebeccapurple':'#663399',
+    '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',
+    'turquoise':'#40e0d0',
+    'violet':'#ee82ee',
+    'wheat':'#f5deb3',
+    'white':'#ffffff',
+    'whitesmoke':'#f5f5f5',
+    'yellow':'#ffff00',
+    'yellowgreen':'#9acd32'
+};

package/lib/less/data/index.js

@@ -0,0 +1,4 @@
+import colors from './colors';
+import unitConversions from './unit-conversions';
+
+export default { colors, unitConversions };

package/lib/less/data/unit-conversions.js

@@ -0,0 +1,21 @@
+export default {
+    length: {
+        'm': 1,
+        'cm': 0.01,
+        'mm': 0.001,
+        'in': 0.0254,
+        'px': 0.0254 / 96,
+        'pt': 0.0254 / 72,
+        'pc': 0.0254 / 72 * 12
+    },
+    duration: {
+        's': 1,
+        'ms': 0.001
+    },
+    angle: {
+        'rad': 1 / (2 * Math.PI),
+        'deg': 1 / 360,
+        'grad': 1 / 400,
+        'turn': 1
+    }
+};

package/lib/less/default-options.js

@@ -0,0 +1,68 @@
+// Export a new default each time
+export default () => ({
+    /* Inline Javascript - @plugin still allowed */
+    javascriptEnabled: false,
+
+    /* Outputs a makefile import dependency list to stdout. */
+    depends: false,
+
+    /* (DEPRECATED) Compress using less built-in compression. 
+  * This does an okay job but does not utilise all the tricks of 
+  * dedicated css compression. */
+    compress: false,
+
+    /* Runs the less parser and just reports errors without any output. */
+    lint: false,
+
+    /* Sets available include paths.
+  * If the file in an @import rule does not exist at that exact location, 
+  * less will look for it at the location(s) passed to this option. 
+  * You might use this for instance to specify a path to a library which 
+  * you want to be referenced simply and relatively in the less files. */
+    paths: [],
+
+    /* color output in the terminal */
+    color: true,
+
+    /* The strictImports controls whether the compiler will allow an @import inside of either 
+  * @media blocks or (a later addition) other selector blocks.
+  * See: https://github.com/less/less.js/issues/656 */
+    strictImports: false,
+
+    /* Allow Imports from Insecure HTTPS Hosts */
+    insecure: false,
+
+    /* Allows you to add a path to every generated import and url in your css. 
+  * This does not affect less import statements that are processed, just ones 
+  * that are left in the output css. */
+    rootpath: '',
+
+    /* By default URLs are kept as-is, so if you import a file in a sub-directory 
+  * that references an image, exactly the same URL will be output in the css. 
+  * This option allows you to re-write URL's in imported files so that the 
+  * URL is always relative to the base imported file */
+    rewriteUrls: false,
+
+    /* How to process math 
+  *   0 always           - eagerly try to solve all operations
+  *   1 parens-division  - require parens for division "/"
+  *   2 parens | strict  - require parens for all operations
+  *   3 strict-legacy    - legacy strict behavior (super-strict)
+  */
+    math: 0,
+
+    /* Without this option, less attempts to guess at the output unit when it does maths. */
+    strictUnits: false,
+
+    /* Effectively the declaration is put at the top of your base Less file, 
+  * meaning it can be used but it also can be overridden if this variable 
+  * is defined in the file. */
+    globalVars: null,
+
+    /* As opposed to the global variable option, this puts the declaration at the
+  * end of your base file, meaning it will override anything defined in your Less file. */
+    modifyVars: null,
+
+    /* This option allows you to specify a argument to go on to every URL.  */
+    urlArgs: ''
+});

package/lib/less/environment/abstract-file-manager.js

@@ -0,0 +1,127 @@
+class AbstractFileManager {
+    getPath(filename) {
+        let j = filename.lastIndexOf('?');
+        if (j > 0) {
+            filename = filename.slice(0, j);
+        }
+        j = filename.lastIndexOf('/');
+        if (j < 0) {
+            j = filename.lastIndexOf('\\');
+        }
+        if (j < 0) {
+            return '';
+        }
+        return filename.slice(0, j + 1);
+    }
+
+    tryAppendExtension(path, ext) {
+        return /(\.[a-z]*$)|([\?;].*)$/.test(path) ? path : path + ext;
+    }
+
+    tryAppendLessExtension(path) {
+        return this.tryAppendExtension(path, '.less');
+    };
+
+    supportsSync() { return false; }
+
+    alwaysMakePathsAbsolute() { return false; }
+
+    isPathAbsolute(filename) {
+        return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
+    }
+    // TODO: pull out / replace?
+    join(basePath, laterPath) {
+        if (!basePath) {
+            return laterPath;
+        }
+        return basePath + laterPath;
+    };
+
+    pathDiff(url, baseUrl) {
+        // diff between two paths to create a relative path
+        const urlParts = this.extractUrlParts(url);
+        const baseUrlParts = this.extractUrlParts(baseUrl);
+
+        let i;
+        let max;
+        let urlDirectories;
+        let baseUrlDirectories;
+        let 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;
+    };
+    // helper function, not part of API
+    extractUrlParts(url, baseUrl) {
+        // urlParts[1] = protocol://hostname/ OR /
+        // urlParts[2] = / if path relative to host base
+        // urlParts[3] = directories
+        // urlParts[4] = filename
+        // urlParts[5] = parameters
+
+        const urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i;
+
+        const urlParts = url.match(urlPartsRegex);
+        const returner = {};
+        let rawDirectories = [];
+        const directories = [];
+        let i;
+        let baseUrlParts;
+
+        if (!urlParts) {
+            throw new Error(`Could not parse sheet href - '${url}'`);
+        }
+
+        // Stylesheets in IE don't always return the full path
+        if (baseUrl && (!urlParts[1] || urlParts[2])) {
+            baseUrlParts = baseUrl.match(urlPartsRegex);
+            if (!baseUrlParts) {
+                throw new Error(`Could not parse page url - '${baseUrl}'`);
+            }
+            urlParts[1] = urlParts[1] || baseUrlParts[1] || '';
+            if (!urlParts[2]) {
+                urlParts[3] = baseUrlParts[3] + urlParts[3];
+            }
+        }
+
+        if (urlParts[3]) {
+            rawDirectories = urlParts[3].replace(/\\/g, '/').split('/');
+
+            // collapse '..' and skip '.'
+            for (i = 0; i < rawDirectories.length; i++) {
+
+                if (rawDirectories[i] === '..') {
+                    directories.pop();
+                }
+                else if (rawDirectories[i] !== '.') {
+                    directories.push(rawDirectories[i]);
+                }
+            
+            }
+        }
+
+        returner.hostPart = urlParts[1];
+        returner.directories = directories;
+        returner.rawPath = (urlParts[1] || '') + rawDirectories.join('/');
+        returner.path = (urlParts[1] || '') + directories.join('/');
+        returner.filename = urlParts[4];
+        returner.fileUrl = returner.path + (urlParts[4] || '');
+        returner.url = returner.fileUrl + (urlParts[5] || '');
+        return returner;
+    };
+}
+
+export default AbstractFileManager;