less 3.10.1 → 3.11.1

package/packages/css-parser/node_modules/chevrotain/lib/src/generate/generate.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../utils/utils");
+var gast_public_1 = require("../parse/grammar/gast/gast_public");
+/**
+ * Missing features
+ * 1. Rule arguments
+ * 2. Gates
+ * 3. embedded actions
+ */
+var NL = "\n";
+function genUmdModule(options) {
+    return "\n(function (root, factory) {\n    if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define(['chevrotain'], factory);\n    } else if (typeof module === 'object' && module.exports) {\n        // Node. Does not work with strict CommonJS, but\n        // only CommonJS-like environments that support module.exports,\n        // like Node.\n        module.exports = factory(require('chevrotain'));\n    } else {\n        // Browser globals (root is window)\n        root.returnExports = factory(root.b);\n    }\n}(typeof self !== 'undefined' ? self : this, function (chevrotain) {\n\n" + genClass(options) + "\n    \nreturn {\n    " + options.name + ": " + options.name + " \n}\n}));\n";
+}
+exports.genUmdModule = genUmdModule;
+function genWrapperFunction(options) {
+    return "    \n" + genClass(options) + "\nreturn new " + options.name + "(tokenVocabulary, config)    \n";
+}
+exports.genWrapperFunction = genWrapperFunction;
+function genClass(options) {
+    // TODO: how to pass the token vocabulary? Constructor? other?
+    var result = "\nfunction " + options.name + "(tokenVocabulary, config) {\n    // invoke super constructor\n    // No support for embedded actions currently, so we can 'hardcode'\n    // The use of CstParser.\n    chevrotain.CstParser.call(this, tokenVocabulary, config)\n\n    const $ = this\n\n    " + genAllRules(options.rules) + "\n\n    // very important to call this after all the rules have been defined.\n    // otherwise the parser may not work correctly as it will lack information\n    // derived during the self analysis phase.\n    this.performSelfAnalysis(this)\n}\n\n// inheritance as implemented in javascript in the previous decade... :(\n" + options.name + ".prototype = Object.create(chevrotain.CstParser.prototype)\n" + options.name + ".prototype.constructor = " + options.name + "    \n    ";
+    return result;
+}
+exports.genClass = genClass;
+function genAllRules(rules) {
+    var rulesText = utils_1.map(rules, function (currRule) {
+        return genRule(currRule, 1);
+    });
+    return rulesText.join("\n");
+}
+exports.genAllRules = genAllRules;
+function genRule(prod, n) {
+    var result = indent(n, "$.RULE(\"" + prod.name + "\", function() {") + NL;
+    result += genDefinition(prod.definition, n + 1);
+    result += indent(n + 1, "})") + NL;
+    return result;
+}
+exports.genRule = genRule;
+function genTerminal(prod, n) {
+    var name = prod.terminalType.name;
+    // TODO: potential performance optimization, avoid tokenMap Dictionary access
+    return indent(n, "$.CONSUME" + prod.idx + "(this.tokensMap." + name + ")" + NL);
+}
+exports.genTerminal = genTerminal;
+function genNonTerminal(prod, n) {
+    return indent(n, "$.SUBRULE" + prod.idx + "($." + prod.nonTerminalName + ")" + NL);
+}
+exports.genNonTerminal = genNonTerminal;
+function genAlternation(prod, n) {
+    var result = indent(n, "$.OR" + prod.idx + "([") + NL;
+    var alts = utils_1.map(prod.definition, function (altDef) { return genSingleAlt(altDef, n + 1); });
+    result += alts.join("," + NL);
+    result += NL + indent(n, "])" + NL);
+    return result;
+}
+exports.genAlternation = genAlternation;
+function genSingleAlt(prod, n) {
+    var result = indent(n, "{") + NL;
+    if (prod.name) {
+        result += indent(n + 1, "NAME: \"" + prod.name + "\",") + NL;
+    }
+    result += indent(n + 1, "ALT: function() {") + NL;
+    result += genDefinition(prod.definition, n + 1);
+    result += indent(n + 1, "}") + NL;
+    result += indent(n, "}");
+    return result;
+}
+exports.genSingleAlt = genSingleAlt;
+function genProd(prod, n) {
+    /* istanbul ignore else */
+    if (prod instanceof gast_public_1.NonTerminal) {
+        return genNonTerminal(prod, n);
+    }
+    else if (prod instanceof gast_public_1.Option) {
+        return genDSLRule("OPTION", prod, n);
+    }
+    else if (prod instanceof gast_public_1.RepetitionMandatory) {
+        return genDSLRule("AT_LEAST_ONE", prod, n);
+    }
+    else if (prod instanceof gast_public_1.RepetitionMandatoryWithSeparator) {
+        return genDSLRule("AT_LEAST_ONE_SEP", prod, n);
+    }
+    else if (prod instanceof gast_public_1.RepetitionWithSeparator) {
+        return genDSLRule("MANY_SEP", prod, n);
+    }
+    else if (prod instanceof gast_public_1.Repetition) {
+        return genDSLRule("MANY", prod, n);
+    }
+    else if (prod instanceof gast_public_1.Alternation) {
+        return genAlternation(prod, n);
+    }
+    else if (prod instanceof gast_public_1.Terminal) {
+        return genTerminal(prod, n);
+    }
+    else if (prod instanceof gast_public_1.Flat) {
+        return genDefinition(prod.definition, n);
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+function genDSLRule(dslName, prod, n) {
+    var result = indent(n, "$." + (dslName + prod.idx) + "(");
+    if (prod.name || prod.separator) {
+        result += "{" + NL;
+        if (prod.name) {
+            result += indent(n + 1, "NAME: \"" + prod.name + "\"") + "," + NL;
+        }
+        if (prod.separator) {
+            result +=
+                indent(n + 1, "SEP: this.tokensMap." + prod.separator.name) +
+                    "," +
+                    NL;
+        }
+        result += "DEF: " + genDefFunction(prod.definition, n + 2) + NL;
+        result += indent(n, "}") + NL;
+    }
+    else {
+        result += genDefFunction(prod.definition, n + 1);
+    }
+    result += indent(n, ")") + NL;
+    return result;
+}
+function genDefFunction(definition, n) {
+    var def = "function() {" + NL;
+    def += genDefinition(definition, n);
+    def += indent(n, "}") + NL;
+    return def;
+}
+function genDefinition(def, n) {
+    var result = "";
+    utils_1.forEach(def, function (prod) {
+        result += genProd(prod, n + 1);
+    });
+    return result;
+}
+function indent(howMuch, text) {
+    var spaces = Array(howMuch * 4 + 1).join(" ");
+    return spaces + text;
+}
+//# sourceMappingURL=generate.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/generate/generate_public.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var generate_1 = require("./generate");
+function generateParserFactory(options) {
+    var wrapperText = generate_1.genWrapperFunction({
+        name: options.name,
+        rules: options.rules
+    });
+    var constructorWrapper = new Function("tokenVocabulary", "config", "chevrotain", wrapperText);
+    return function (config) {
+        return constructorWrapper(options.tokenVocabulary, config, 
+        // TODO: check how the require is transpiled/webpacked
+        require("../api"));
+    };
+}
+exports.generateParserFactory = generateParserFactory;
+function generateParserModule(options) {
+    return generate_1.genUmdModule({ name: options.name, rules: options.rules });
+}
+exports.generateParserModule = generateParserModule;
+//# sourceMappingURL=generate_public.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/lang/lang_extensions.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../utils/utils");
+function classNameFromInstance(instance) {
+    return functionName(instance.constructor);
+}
+exports.classNameFromInstance = classNameFromInstance;
+var FUNC_NAME_REGEXP = /^\s*function\s*(\S*)\s*\(/;
+var NAME = "name";
+/* istanbul ignore next too many hacks for IE/old versions of node.js here*/
+function functionName(func) {
+    // Engines that support Function.prototype.name OR the nth (n>1) time after
+    // the name has been computed in the following else block.
+    var existingNameProp = func.name;
+    if (existingNameProp) {
+        return existingNameProp;
+    }
+    // hack for IE and engines that do not support Object.defineProperty on function.name (Node.js 0.10 && 0.12)
+    var computedName = func.toString().match(FUNC_NAME_REGEXP)[1];
+    return computedName;
+}
+exports.functionName = functionName;
+/**
+ * @returns {boolean} - has the property been successfully defined
+ */
+function defineNameProp(obj, nameValue) {
+    var namePropDescriptor = Object.getOwnPropertyDescriptor(obj, NAME);
+    /* istanbul ignore else -> will only run in old versions of node.js */
+    if (utils_1.isUndefined(namePropDescriptor) || namePropDescriptor.configurable) {
+        Object.defineProperty(obj, NAME, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: nameValue
+        });
+        return true;
+    }
+    /* istanbul ignore next -> will only run in old versions of node.js */
+    return false;
+}
+exports.defineNameProp = defineNameProp;
+//# sourceMappingURL=lang_extensions.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: can this be removed? where is it used?
+exports.IN = "_~IN~_";
+//# sourceMappingURL=constants.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/cst/cst.js

@@ -0,0 +1,194 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../utils/utils");
+var keys_1 = require("../grammar/keys");
+var gast_public_1 = require("../grammar/gast/gast_public");
+var gast_visitor_public_1 = require("../grammar/gast/gast_visitor_public");
+/**
+ * This nodeLocation tracking is not efficient and should only be used
+ * when error recovery is enabled or the Token Vector contains virtual Tokens
+ * (e.g, Python Indent/Outdent)
+ * As it executes the calculation for every single terminal/nonTerminal
+ * and does not rely on the fact the token vector is **sorted**
+ */
+function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {
+    // First (valid) update for this cst node
+    if (isNaN(currNodeLocation.startOffset) === true) {
+        // assumption1: Token location information is either NaN or a valid number
+        // assumption2: Token location information is fully valid if it exist
+        // (both start/end offsets exist and are numbers).
+        currNodeLocation.startOffset = newLocationInfo.startOffset;
+        currNodeLocation.endOffset = newLocationInfo.endOffset;
+    }
+    // Once the startOffset has been updated with a valid number it should never receive
+    // any farther updates as the Token vector is sorted.
+    // We still have to check this this condition for every new possible location info
+    // because with error recovery enabled we may encounter invalid tokens (NaN location props)
+    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
+        currNodeLocation.endOffset = newLocationInfo.endOffset;
+    }
+}
+exports.setNodeLocationOnlyOffset = setNodeLocationOnlyOffset;
+/**
+ * This nodeLocation tracking is not efficient and should only be used
+ * when error recovery is enabled or the Token Vector contains virtual Tokens
+ * (e.g, Python Indent/Outdent)
+ * As it executes the calculation for every single terminal/nonTerminal
+ * and does not rely on the fact the token vector is **sorted**
+ */
+function setNodeLocationFull(currNodeLocation, newLocationInfo) {
+    // First (valid) update for this cst node
+    if (isNaN(currNodeLocation.startOffset) === true) {
+        // assumption1: Token location information is either NaN or a valid number
+        // assumption2: Token location information is fully valid if it exist
+        // (all start/end props exist and are numbers).
+        currNodeLocation.startOffset = newLocationInfo.startOffset;
+        currNodeLocation.startColumn = newLocationInfo.startColumn;
+        currNodeLocation.startLine = newLocationInfo.startLine;
+        currNodeLocation.endOffset = newLocationInfo.endOffset;
+        currNodeLocation.endColumn = newLocationInfo.endColumn;
+        currNodeLocation.endLine = newLocationInfo.endLine;
+    }
+    // Once the start props has been updated with a valid number it should never receive
+    // any farther updates as the Token vector is sorted.
+    // We still have to check this this condition for every new possible location info
+    // because with error recovery enabled we may encounter invalid tokens (NaN location props)
+    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
+        currNodeLocation.endOffset = newLocationInfo.endOffset;
+        currNodeLocation.endColumn = newLocationInfo.endColumn;
+        currNodeLocation.endLine = newLocationInfo.endLine;
+    }
+}
+exports.setNodeLocationFull = setNodeLocationFull;
+function addTerminalToCst(node, token, tokenTypeName) {
+    if (node.children[tokenTypeName] === undefined) {
+        node.children[tokenTypeName] = [token];
+    }
+    else {
+        node.children[tokenTypeName].push(token);
+    }
+}
+exports.addTerminalToCst = addTerminalToCst;
+function addNoneTerminalToCst(node, ruleName, ruleResult) {
+    if (node.children[ruleName] === undefined) {
+        node.children[ruleName] = [ruleResult];
+    }
+    else {
+        node.children[ruleName].push(ruleResult);
+    }
+}
+exports.addNoneTerminalToCst = addNoneTerminalToCst;
+var NamedDSLMethodsCollectorVisitor = /** @class */ (function (_super) {
+    __extends(NamedDSLMethodsCollectorVisitor, _super);
+    function NamedDSLMethodsCollectorVisitor(ruleIdx) {
+        var _this = _super.call(this) || this;
+        _this.result = [];
+        _this.ruleIdx = ruleIdx;
+        return _this;
+    }
+    NamedDSLMethodsCollectorVisitor.prototype.collectNamedDSLMethod = function (node, newNodeConstructor, methodIdx) {
+        // TODO: better hack to copy what we need here...
+        if (!utils_1.isUndefined(node.name)) {
+            // copy without name so this will indeed be processed later.
+            var nameLessNode 
+            /* istanbul ignore else */
+            = void 0;
+            /* istanbul ignore else */
+            if (node instanceof gast_public_1.Option ||
+                node instanceof gast_public_1.Repetition ||
+                node instanceof gast_public_1.RepetitionMandatory ||
+                node instanceof gast_public_1.Alternation) {
+                nameLessNode = new newNodeConstructor({
+                    definition: node.definition,
+                    idx: node.idx
+                });
+            }
+            else if (node instanceof gast_public_1.RepetitionMandatoryWithSeparator ||
+                node instanceof gast_public_1.RepetitionWithSeparator) {
+                nameLessNode = new newNodeConstructor({
+                    definition: node.definition,
+                    idx: node.idx,
+                    separator: node.separator
+                });
+            }
+            else {
+                throw Error("non exhaustive match");
+            }
+            var def = [nameLessNode];
+            var key = keys_1.getKeyForAutomaticLookahead(this.ruleIdx, methodIdx, node.idx);
+            this.result.push({ def: def, key: key, name: node.name, orgProd: node });
+        }
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitOption = function (node) {
+        this.collectNamedDSLMethod(node, gast_public_1.Option, keys_1.OPTION_IDX);
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitRepetition = function (node) {
+        this.collectNamedDSLMethod(node, gast_public_1.Repetition, keys_1.MANY_IDX);
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitRepetitionMandatory = function (node) {
+        this.collectNamedDSLMethod(node, gast_public_1.RepetitionMandatory, keys_1.AT_LEAST_ONE_IDX);
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitRepetitionMandatoryWithSeparator = function (node) {
+        this.collectNamedDSLMethod(node, gast_public_1.RepetitionMandatoryWithSeparator, keys_1.AT_LEAST_ONE_SEP_IDX);
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitRepetitionWithSeparator = function (node) {
+        this.collectNamedDSLMethod(node, gast_public_1.RepetitionWithSeparator, keys_1.MANY_SEP_IDX);
+    };
+    NamedDSLMethodsCollectorVisitor.prototype.visitAlternation = function (node) {
+        var _this = this;
+        this.collectNamedDSLMethod(node, gast_public_1.Alternation, keys_1.OR_IDX);
+        var hasMoreThanOneAlternative = node.definition.length > 1;
+        utils_1.forEach(node.definition, function (currFlatAlt, altIdx) {
+            if (!utils_1.isUndefined(currFlatAlt.name)) {
+                var def = currFlatAlt.definition;
+                if (hasMoreThanOneAlternative) {
+                    def = [new gast_public_1.Option({ definition: currFlatAlt.definition })];
+                }
+                else {
+                    // mandatory
+                    def = currFlatAlt.definition;
+                }
+                var key = keys_1.getKeyForAltIndex(_this.ruleIdx, keys_1.OR_IDX, node.idx, altIdx);
+                _this.result.push({
+                    def: def,
+                    key: key,
+                    name: currFlatAlt.name,
+                    orgProd: currFlatAlt
+                });
+            }
+        });
+    };
+    return NamedDSLMethodsCollectorVisitor;
+}(gast_visitor_public_1.GAstVisitor));
+exports.NamedDSLMethodsCollectorVisitor = NamedDSLMethodsCollectorVisitor;
+function expandAllNestedRuleNames(topRules, fullToShortName) {
+    var result = {
+        allRuleNames: []
+    };
+    utils_1.forEach(topRules, function (currTopRule) {
+        var currTopRuleShortName = fullToShortName[currTopRule.name];
+        result.allRuleNames.push(currTopRule.name);
+        var namedCollectorVisitor = new NamedDSLMethodsCollectorVisitor(currTopRuleShortName);
+        currTopRule.accept(namedCollectorVisitor);
+        utils_1.forEach(namedCollectorVisitor.result, function (_a) {
+            var def = _a.def, key = _a.key, name = _a.name;
+            result.allRuleNames.push(currTopRule.name + name);
+        });
+    });
+    return result;
+}
+exports.expandAllNestedRuleNames = expandAllNestedRuleNames;
+//# sourceMappingURL=cst.js.map

package/packages/css-parser/node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../utils/utils");
+var lang_extensions_1 = require("../../lang/lang_extensions");
+var checks_1 = require("../grammar/checks");
+function defaultVisit(ctx, param) {
+    var childrenNames = utils_1.keys(ctx);
+    var childrenNamesLength = childrenNames.length;
+    for (var i = 0; i < childrenNamesLength; i++) {
+        var currChildName = childrenNames[i];
+        var currChildArray = ctx[currChildName];
+        var currChildArrayLength = currChildArray.length;
+        for (var j = 0; j < currChildArrayLength; j++) {
+            var currChild = currChildArray[j];
+            // distinction between Tokens Children and CstNode children
+            if (currChild.tokenTypeIdx === undefined) {
+                if (currChild.fullName !== undefined) {
+                    this[currChild.fullName](currChild.children, param);
+                }
+                else {
+                    this[currChild.name](currChild.children, param);
+                }
+            }
+        }
+    }
+    // defaultVisit does not support generic out param
+    return undefined;
+}
+exports.defaultVisit = defaultVisit;
+function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {
+    var derivedConstructor = function () { };
+    // can be overwritten according to:
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
+    // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
+    lang_extensions_1.defineNameProp(derivedConstructor, grammarName + "BaseSemantics");
+    var semanticProto = {
+        visit: function (cstNode, param) {
+            // enables writing more concise visitor methods when CstNode has only a single child
+            if (utils_1.isArray(cstNode)) {
+                // A CST Node's children dictionary can never have empty arrays as values
+                // If a key is defined there will be at least one element in the corresponding value array.
+                cstNode = cstNode[0];
+            }
+            // enables passing optional CstNodes concisely.
+            if (utils_1.isUndefined(cstNode)) {
+                return undefined;
+            }
+            if (cstNode.fullName !== undefined) {
+                return this[cstNode.fullName](cstNode.children, param);
+            }
+            else {
+                return this[cstNode.name](cstNode.children, param);
+            }
+        },
+        validateVisitor: function () {
+            var semanticDefinitionErrors = validateVisitor(this, ruleNames);
+            if (!utils_1.isEmpty(semanticDefinitionErrors)) {
+                var errorMessages = utils_1.map(semanticDefinitionErrors, function (currDefError) { return currDefError.msg; });
+                throw Error("Errors Detected in CST Visitor <" + lang_extensions_1.functionName(this.constructor) + ">:\n\t" +
+                    ("" + errorMessages.join("\n\n").replace(/\n/g, "\n\t")));
+            }
+        }
+    };
+    derivedConstructor.prototype = semanticProto;
+    derivedConstructor.prototype.constructor = derivedConstructor;
+    derivedConstructor._RULE_NAMES = ruleNames;
+    return derivedConstructor;
+}
+exports.createBaseSemanticVisitorConstructor = createBaseSemanticVisitorConstructor;
+function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseConstructor) {
+    var derivedConstructor = function () { };
+    // can be overwritten according to:
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
+    // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
+    lang_extensions_1.defineNameProp(derivedConstructor, grammarName + "BaseSemanticsWithDefaults");
+    var withDefaultsProto = Object.create(baseConstructor.prototype);
+    utils_1.forEach(ruleNames, function (ruleName) {
+        withDefaultsProto[ruleName] = defaultVisit;
+    });
+    derivedConstructor.prototype = withDefaultsProto;
+    derivedConstructor.prototype.constructor = derivedConstructor;
+    return derivedConstructor;
+}
+exports.createBaseVisitorConstructorWithDefaults = createBaseVisitorConstructorWithDefaults;
+var CstVisitorDefinitionError;
+(function (CstVisitorDefinitionError) {
+    CstVisitorDefinitionError[CstVisitorDefinitionError["REDUNDANT_METHOD"] = 0] = "REDUNDANT_METHOD";
+    CstVisitorDefinitionError[CstVisitorDefinitionError["MISSING_METHOD"] = 1] = "MISSING_METHOD";
+})(CstVisitorDefinitionError = exports.CstVisitorDefinitionError || (exports.CstVisitorDefinitionError = {}));
+function validateVisitor(visitorInstance, ruleNames) {
+    var missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);
+    var redundantErrors = validateRedundantMethods(visitorInstance, ruleNames);
+    return missingErrors.concat(redundantErrors);
+}
+exports.validateVisitor = validateVisitor;
+function validateMissingCstMethods(visitorInstance, ruleNames) {
+    var errors = utils_1.map(ruleNames, function (currRuleName) {
+        if (!utils_1.isFunction(visitorInstance[currRuleName])) {
+            return {
+                msg: "Missing visitor method: <" + currRuleName + "> on " + lang_extensions_1.functionName(visitorInstance.constructor) + " CST Visitor.",
+                type: CstVisitorDefinitionError.MISSING_METHOD,
+                methodName: currRuleName
+            };
+        }
+    });
+    return utils_1.compact(errors);
+}
+exports.validateMissingCstMethods = validateMissingCstMethods;
+var VALID_PROP_NAMES = ["constructor", "visit", "validateVisitor"];
+function validateRedundantMethods(visitorInstance, ruleNames) {
+    var errors = [];
+    for (var prop in visitorInstance) {
+        if (checks_1.validTermsPattern.test(prop) &&
+            utils_1.isFunction(visitorInstance[prop]) &&
+            !utils_1.contains(VALID_PROP_NAMES, prop) &&
+            !utils_1.contains(ruleNames, prop)) {
+            errors.push({
+                msg: "Redundant visitor method: <" + prop + "> on " + lang_extensions_1.functionName(visitorInstance.constructor) + " CST Visitor\n" +
+                    "There is no Grammar Rule corresponding to this method's name.\n" +
+                    ("For utility methods on visitor classes use methods names that do not match /" + checks_1.validTermsPattern.source + "/."),
+                type: CstVisitorDefinitionError.REDUNDANT_METHOD,
+                methodName: prop
+            });
+        }
+    }
+    return errors;
+}
+exports.validateRedundantMethods = validateRedundantMethods;
+//# sourceMappingURL=cst_visitor.js.map