less 3.10.1 → 3.11.1

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/utils/utils.js

@@ -0,0 +1,420 @@
+/*
+ Utils using lodash style API. (not necessarily 100% compliant) for functional and other utils.
+ These utils should replace usage of lodash in the production code base. not because they are any better...
+ but for the purpose of being a dependency free library.
+
+ The hotspots in the code are already written in imperative style for performance reasons.
+ so writing several dozen utils which may be slower than the original lodash, does not matter as much
+ considering they will not be invoked in hotspots...
+ */
+export function isEmpty(arr) {
+    return arr && arr.length === 0;
+}
+export function keys(obj) {
+    if (obj === undefined || obj === null) {
+        return [];
+    }
+    return Object.keys(obj);
+}
+export function values(obj) {
+    var vals = [];
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        vals.push(obj[keys[i]]);
+    }
+    return vals;
+}
+export function mapValues(obj, callback) {
+    var result = [];
+    var objKeys = keys(obj);
+    for (var idx = 0; idx < objKeys.length; idx++) {
+        var currKey = objKeys[idx];
+        result.push(callback.call(null, obj[currKey], currKey));
+    }
+    return result;
+}
+export function map(arr, callback) {
+    var result = [];
+    for (var idx = 0; idx < arr.length; idx++) {
+        result.push(callback.call(null, arr[idx], idx));
+    }
+    return result;
+}
+export function flatten(arr) {
+    var result = [];
+    for (var idx = 0; idx < arr.length; idx++) {
+        var currItem = arr[idx];
+        if (Array.isArray(currItem)) {
+            result = result.concat(flatten(currItem));
+        }
+        else {
+            result.push(currItem);
+        }
+    }
+    return result;
+}
+export function first(arr) {
+    return isEmpty(arr) ? undefined : arr[0];
+}
+export function last(arr) {
+    var len = arr && arr.length;
+    return len ? arr[len - 1] : undefined;
+}
+export function forEach(collection, iteratorCallback) {
+    /* istanbul ignore else */
+    if (Array.isArray(collection)) {
+        for (var i = 0; i < collection.length; i++) {
+            iteratorCallback.call(null, collection[i], i);
+        }
+    }
+    else if (isObject(collection)) {
+        var colKeys = keys(collection);
+        for (var i = 0; i < colKeys.length; i++) {
+            var key = colKeys[i];
+            var value = collection[key];
+            iteratorCallback.call(null, value, key);
+        }
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+export function isString(item) {
+    return typeof item === "string";
+}
+export function isUndefined(item) {
+    return item === undefined;
+}
+export function isFunction(item) {
+    return item instanceof Function;
+}
+export function drop(arr, howMuch) {
+    if (howMuch === void 0) { howMuch = 1; }
+    return arr.slice(howMuch, arr.length);
+}
+export function dropRight(arr, howMuch) {
+    if (howMuch === void 0) { howMuch = 1; }
+    return arr.slice(0, arr.length - howMuch);
+}
+export function filter(arr, predicate) {
+    var result = [];
+    if (Array.isArray(arr)) {
+        for (var i = 0; i < arr.length; i++) {
+            var item = arr[i];
+            if (predicate.call(null, item)) {
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+export function reject(arr, predicate) {
+    return filter(arr, function (item) { return !predicate(item); });
+}
+export function pick(obj, predicate) {
+    var keys = Object.keys(obj);
+    var result = {};
+    for (var i = 0; i < keys.length; i++) {
+        var currKey = keys[i];
+        var currItem = obj[currKey];
+        if (predicate(currItem)) {
+            result[currKey] = currItem;
+        }
+    }
+    return result;
+}
+export function has(obj, prop) {
+    if (isObject(obj)) {
+        return obj.hasOwnProperty(prop);
+    }
+    return false;
+}
+export function contains(arr, item) {
+    return find(arr, function (currItem) { return currItem === item; }) !== undefined ? true : false;
+}
+/**
+ * shallow clone
+ */
+export function cloneArr(arr) {
+    var newArr = [];
+    for (var i = 0; i < arr.length; i++) {
+        newArr.push(arr[i]);
+    }
+    return newArr;
+}
+/**
+ * shallow clone
+ */
+export function cloneObj(obj) {
+    var clonedObj = {};
+    for (var key in obj) {
+        /* istanbul ignore else */
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = obj[key];
+        }
+    }
+    return clonedObj;
+}
+export function find(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        if (predicate.call(null, item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+export function findAll(arr, predicate) {
+    var found = [];
+    for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        if (predicate.call(null, item)) {
+            found.push(item);
+        }
+    }
+    return found;
+}
+export function reduce(arrOrObj, iterator, initial) {
+    var isArr = Array.isArray(arrOrObj);
+    var vals = isArr ? arrOrObj : values(arrOrObj);
+    var objKeys = isArr ? [] : keys(arrOrObj);
+    var accumulator = initial;
+    for (var i = 0; i < vals.length; i++) {
+        accumulator = iterator.call(null, accumulator, vals[i], isArr ? i : objKeys[i]);
+    }
+    return accumulator;
+}
+export function compact(arr) {
+    return reject(arr, function (item) { return item === null || item === undefined; });
+}
+export function uniq(arr, identity) {
+    if (identity === void 0) { identity = function (item) { return item; }; }
+    var identities = [];
+    return reduce(arr, function (result, currItem) {
+        var currIdentity = identity(currItem);
+        if (contains(identities, currIdentity)) {
+            return result;
+        }
+        else {
+            identities.push(currIdentity);
+            return result.concat(currItem);
+        }
+    }, []);
+}
+export function partial(func) {
+    var restArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        restArgs[_i - 1] = arguments[_i];
+    }
+    var firstArg = [null];
+    var allArgs = firstArg.concat(restArgs);
+    return Function.bind.apply(func, allArgs);
+}
+export function isArray(obj) {
+    return Array.isArray(obj);
+}
+export function isRegExp(obj) {
+    return obj instanceof RegExp;
+}
+export function isObject(obj) {
+    return obj instanceof Object;
+}
+export function every(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        if (!predicate(arr[i], i)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function difference(arr, values) {
+    return reject(arr, function (item) { return contains(values, item); });
+}
+export function some(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        if (predicate(arr[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function indexOf(arr, value) {
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === value) {
+            return i;
+        }
+    }
+    return -1;
+}
+export function sortBy(arr, orderFunc) {
+    var result = cloneArr(arr);
+    result.sort(function (a, b) { return orderFunc(a) - orderFunc(b); });
+    return result;
+}
+export function zipObject(keys, values) {
+    if (keys.length !== values.length) {
+        throw Error("can't zipObject with different number of keys and values!");
+    }
+    var result = {};
+    for (var i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}
+/**
+ * mutates! (and returns) target
+ */
+export function assign(target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    for (var i = 0; i < sources.length; i++) {
+        var curSource = sources[i];
+        var currSourceKeys = keys(curSource);
+        for (var j = 0; j < currSourceKeys.length; j++) {
+            var currKey = currSourceKeys[j];
+            target[currKey] = curSource[currKey];
+        }
+    }
+    return target;
+}
+/**
+ * mutates! (and returns) target
+ */
+export function assignNoOverwrite(target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    for (var i = 0; i < sources.length; i++) {
+        var curSource = sources[i];
+        if (isUndefined(curSource)) {
+            continue;
+        }
+        var currSourceKeys = keys(curSource);
+        for (var j = 0; j < currSourceKeys.length; j++) {
+            var currKey = currSourceKeys[j];
+            if (!has(target, currKey)) {
+                target[currKey] = curSource[currKey];
+            }
+        }
+    }
+    return target;
+}
+export function defaults() {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    return assignNoOverwrite.apply(null, [{}].concat(sources));
+}
+export function groupBy(arr, groupKeyFunc) {
+    var result = {};
+    forEach(arr, function (item) {
+        var currGroupKey = groupKeyFunc(item);
+        var currGroupArr = result[currGroupKey];
+        if (currGroupArr) {
+            currGroupArr.push(item);
+        }
+        else {
+            result[currGroupKey] = [item];
+        }
+    });
+    return result;
+}
+/**
+ * Merge obj2 into obj1.
+ * Will overwrite existing properties with the same name
+ */
+export function merge(obj1, obj2) {
+    var result = cloneObj(obj1);
+    var keys2 = keys(obj2);
+    for (var i = 0; i < keys2.length; i++) {
+        var key = keys2[i];
+        var value = obj2[key];
+        result[key] = value;
+    }
+    return result;
+}
+export function NOOP() { }
+export function IDENTITY(item) {
+    return item;
+}
+/**
+ * Will return a new packed array with same values.
+ */
+export function packArray(holeyArr) {
+    var result = [];
+    for (var i = 0; i < holeyArr.length; i++) {
+        var orgValue = holeyArr[i];
+        result.push(orgValue !== undefined ? orgValue : undefined);
+    }
+    return result;
+}
+export function PRINT_ERROR(msg) {
+    /* istanbul ignore else - can't override global.console in node.js */
+    if (console && console.error) {
+        console.error("Error: " + msg);
+    }
+}
+export function PRINT_WARNING(msg) {
+    /* istanbul ignore else - can't override global.console in node.js*/
+    if (console && console.warn) {
+        // TODO: modify docs accordingly
+        console.warn("Warning: " + msg);
+    }
+}
+export function isES2015MapSupported() {
+    return typeof Map === "function";
+}
+export function applyMixins(derivedCtor, baseCtors) {
+    baseCtors.forEach(function (baseCtor) {
+        var baseProto = baseCtor.prototype;
+        Object.getOwnPropertyNames(baseProto).forEach(function (propName) {
+            if (propName === "constructor") {
+                return;
+            }
+            var basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);
+            // Handle Accessors
+            if (basePropDescriptor &&
+                (basePropDescriptor.get || basePropDescriptor.set)) {
+                Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);
+            }
+            else {
+                derivedCtor.prototype[propName] = baseCtor.prototype[propName];
+            }
+        });
+    });
+}
+// base on: https://github.com/petkaantonov/bluebird/blob/b97c0d2d487e8c5076e8bd897e0dcd4622d31846/src/util.js#L201-L216
+export function toFastProperties(toBecomeFast) {
+    function FakeConstructor() { }
+    // If our object is used as a constructor it would receive
+    FakeConstructor.prototype = toBecomeFast;
+    var fakeInstance = new FakeConstructor();
+    function fakeAccess() {
+        return typeof fakeInstance.bar;
+    }
+    // help V8 understand this is a "real" prototype by actually using
+    // the fake instance.
+    fakeAccess();
+    fakeAccess();
+    return toBecomeFast;
+    // Eval prevents optimization of this method (even though this is dead code)
+    /* istanbul ignore next */
+    // tslint:disable-next-line
+    eval(toBecomeFast);
+}
+export function peek(arr) {
+    return arr[arr.length - 1];
+}
+/* istanbul ignore next - for performance tracing*/
+export function timer(func) {
+    var start = new Date().getTime();
+    var val = func();
+    var end = new Date().getTime();
+    var total = end - start;
+    return { time: total, value: val };
+}
+//# sourceMappingURL=utils.js.map

package/packages/css-parser/node_modules/chevrotain/lib_esm/src/version.js

@@ -0,0 +1,5 @@
+// needs a separate module as this is required inside chevrotain productive code
+// and also in the entry point for webpack(api.ts).
+// A separate file avoids cyclic dependencies and webpack errors.
+export var VERSION = "6.5.0";
+//# sourceMappingURL=version.js.map

package/packages/css-parser/node_modules/chevrotain/package.json

@@ -0,0 +1,142 @@
+{
+    "name": "chevrotain",
+    "version": "6.5.0",
+    "description": "Chevrotain is a high performance fault tolerant javascript parsing DSL for building recursive decent parsers",
+    "keywords": [
+        "parser",
+        "syntax",
+        "lexical",
+        "analysis",
+        "grammar",
+        "lexer",
+        "tokenizer",
+        "generator",
+        "compiler",
+        "fault",
+        "tolerant"
+    ],
+    "bugs": {
+        "url": "https://github.com/SAP/chevrotain/issues"
+    },
+    "license": "Apache-2.0",
+    "author": {
+        "name": "Shahar Soel"
+    },
+    "files": [
+        "lib_esm/src/**/*.js",
+        "lib/src/**/*.js",
+        "lib/chevrotain.d.ts",
+        "lib/chevrotain.min.js",
+        "lib/chevrotain.js",
+        "readme.md",
+        "LICENSE.TXT",
+        "diagrams/**/*.*",
+        "CHANGELOG.md"
+    ],
+    "main": "lib/src/api.js",
+    "module": "lib_esm/src/api.js",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/SAP/chevrotain.git"
+    },
+    "homepage": "https://sap.github.io/chevrotain/docs/",
+    "scripts": {
+        "---------- CI FLOWS --------": "",
+        "build": "npm-run-all clean lint compile build:esm dts api-site:build bundle",
+        "build:esm": "npm-run-all clean:esm compile:esm",
+        "test": "npm-run-all test:esm compile:def coverage check-coverage karma",
+        "test:esm": "mocha \"./lib_esm/test/**/*spec.js\" --require esm",
+        "version": "tsc ./src/version.ts --outDir lib/src && node ./scripts/version-update.js",
+        "postversion": "npm-run-all website:build website:upload api-site:build api-site:upload",
+        "---------- DEV FLOWS --------": "",
+        "watch": "tsc -w",
+        "unit-tests": "mocha \"./lib/test/**/*spec.js\"",
+        "quick-build": "tsc && yarn run bundle",
+        "---------- BUILD STEPS --------": "",
+        "clean": "shx rm -rf coverage dev lib",
+        "clean:esm": "shx rm -rf lib_esm",
+        "lint": "tslint --project tsconfig.json",
+        "compile": "tsc && node ./scripts/fix-coverage-report.js",
+        "compile:esm": "tsc --project tsconfig.esm.json",
+        "compile:watch": "tsc -w",
+        "compile:def": "npm-run-all compile-def-api compile-def-modules compile-def-namespace",
+        "dts": "node scripts/process-docs.js",
+        "coverage": "nyc mocha \"./lib/test/**/*spec.js\"",
+        "check-coverage": "nyc check-coverage --lines 100 --branches 100 --statements 100 --functions 100",
+        "bundle": "npm-run-all bundle:regular bundle:min bundle:spec",
+        "api-site:build": "typedoc api.d.ts --mode file --out dev/docs --module commonjs --excludeExternals --includeDeclarations --excludePrivate",
+        "api-site:upload": "./scripts/api-site-upload.sh",
+        "website:dev": "vuepress dev docs",
+        "website:build": "vuepress build docs",
+        "website:upload": "./scripts/website-upload.sh",
+        "dead-links": "awesome_bot docs/*.md docs/*/*.md diagrams/*.md examples/*.md examples/*/*.md examples/*/*/*.md readme.md --allow-dupe --allow-redirect --skip-save-results",
+        "karma": "grunt browsers_tests",
+        "coveralls": "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+        "---------- DEFINITIONS --------": "",
+        "compile-def-api": "tsc --noImplicitAny test_integration/definitions/api_type_checking.ts --outDir dev/garbage --lib \"es2015\"",
+        "compile-def-modules": "tsc --noImplicitAny test_integration/definitions/es6_modules.ts --outDir dev/garbage --lib \"es2015\"",
+        "compile-def-namespace": "tsc --noImplicitAny test_integration/definitions/namespaces.ts --module none --outDir dev/garbage --lib \"es2015\"",
+        "---------- BUNDLING --------": "",
+        "bundle:regular": "webpack --config webpack_release.config.js",
+        "bundle:min": "webpack --config webpack_release_min.config.js",
+        "bundle:spec": "webpack --config webpack_specs.config.js"
+    },
+    "dependencies": {
+        "regexp-to-ast": "0.4.0"
+    },
+    "devDependencies": {
+        "@types/chai": "^4.0.10",
+        "@types/mocha": "^5.0.0",
+        "@types/sinon-chai": "^3.2.0",
+        "chai": "^4.1.2",
+        "coveralls": "^3.0.0",
+        "esm": "^3.2.25",
+        "gitty": "^3.6.0",
+        "grunt": "^1.0.1",
+        "grunt-cli": "~1.3.1",
+        "grunt-karma": "~3.0.0",
+        "if-env": "^1.0.0",
+        "jsdom": "13.2.0",
+        "jsonfile": "^5.0.0",
+        "karma": "4.0.0",
+        "karma-chai": "^0.1.0",
+        "karma-chrome-launcher": "~2.2.0",
+        "karma-edge-launcher": "^0.4.2",
+        "karma-firefox-launcher": "~1.1.0",
+        "karma-ie-launcher": "~1.0",
+        "karma-mocha": "^1.3.0",
+        "karma-requirejs": "^1.1.0",
+        "karma-safari-launcher": "^1.0.0",
+        "load-grunt-tasks": "^4.0.0",
+        "nyc": "^13.0.1",
+        "require-from-string": "^2.0.2",
+        "requirejs": "2.3.6",
+        "sinon": "^7.2.3",
+        "sinon-chai": "^3.0.0",
+        "tslint": "^5.8.0",
+        "typedoc": "0.14.2",
+        "typescript": "3.5.3",
+        "vuepress": "^0.14.2",
+        "webpack": "4.29.6",
+        "webpack-cli": "^3.0.0",
+        "xregexp": "^4.2.0"
+    },
+    "typings": "lib/chevrotain.d.ts",
+    "nyc": {
+        "reporter": [
+            "lcov",
+            "text"
+        ],
+        "exclude": [
+            "lib/test/**/*.*",
+            "test/test.config.js"
+        ]
+    },
+    "mocha": {
+        "recursive": true,
+        "reporter": "spec",
+        "require": "./test/test.config",
+        "ui": "bdd"
+    },
+    "gitHead": "d8593c78e919f8f03fce04c2c4860a3022af7e4f"
+}

package/{test/browser/vendor → packages/less/.grunt/grunt-contrib-jasmine}/boot.js

@@ -1,5 +1,3 @@
-// Modified from grunt-contrib-jasmine
-
 /*
 Copyright (c) 2008-2015 Pivotal Labs
 
@@ -129,10 +127,16 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   window.clearInterval = window.clearInterval;
 
   /**
-   * Customized for Less.js
+   * ## Execution
+   *
+   * Replace the browser window's `onload`, ensure it's called, and then run all of the loaded specs. This includes initializing the `HtmlReporter` instance and then executing the loaded Jasmine environment. All of this will happen after all of the specs are loaded.
    */
+  var currentWindowOnload = window.onload;
 
-  window.DEFER = function() {
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
     htmlReporter.initialize();
     env.execute();
   };