less 3.10.1 → 3.11.1

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

@@ -0,0 +1,85 @@
+svg.railroad-diagram path {
+    stroke-width: 3;
+    stroke: black;
+    fill: rgba(0, 0, 0, 0);
+}
+
+svg.railroad-diagram text {
+    font: bold 14px monospace;
+    text-anchor: middle;
+}
+
+svg.railroad-diagram text.label {
+    text-anchor: start;
+}
+
+svg.railroad-diagram text.comment {
+    font: italic 12px monospace;
+}
+
+svg.railroad-diagram g.non-terminal rect {
+    fill: hsl(223, 100%, 83%);
+}
+
+svg.railroad-diagram rect {
+    stroke-width: 3;
+    stroke: black;
+    fill: hsl(190, 100%, 83%);
+}
+
+.diagramHeader {
+    display: inline-block;
+    -webkit-touch-callout: default;
+    -webkit-user-select: text;
+    -khtml-user-select: text;
+    -moz-user-select: text;
+    -ms-user-select: text;
+    user-select: text;
+    font-weight: bold;
+    font-family: monospace;
+    font-size: 18px;
+    margin-bottom: -8px;
+    text-align: center;
+}
+
+.diagramHeaderDef {
+    background-color: lightgreen;
+}
+
+svg.railroad-diagram text {
+    -webkit-touch-callout: default;
+    -webkit-user-select: text;
+    -khtml-user-select: text;
+    -moz-user-select: text;
+    -ms-user-select: text;
+    user-select: text;
+}
+
+svg.railroad-diagram g.non-terminal rect.diagramRectUsage {
+    color: green;
+    fill: yellow;
+    stroke: 5;
+}
+
+svg.railroad-diagram g.terminal rect.diagramRectUsage {
+    color: green;
+    fill: yellow;
+    stroke: 5;
+}
+
+div {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+svg {
+    width: 100%;
+}
+
+svg.railroad-diagram g.non-terminal text {
+    cursor: pointer;
+}

package/packages/css-parser/node_modules/chevrotain/diagrams/src/diagrams_behavior.js

@@ -0,0 +1,225 @@
+;(function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+        // AMD. Register as an anonymous module.
+        define([], factory)
+    } else if (typeof module === "object" && module.exports) {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like environments that support module.exports,
+        // like Node.
+        module.exports = factory()
+    } else {
+        // Browser globals (root is window)
+        root.diagrams_behavior = factory()
+    }
+})(this, function() {
+    /**
+     * @param [scrollingEnabled=true] {boolean} - Is the scrolling from a non-terminal usage to it's definition
+     * enabled. it is enabled by default, but this flow is not relevant in all use cases (playground) and thus
+     * it is parametrized.
+     */
+    function initDiagramsBehavior(scrollingEnabled) {
+        if (scrollingEnabled === undefined) {
+            scrollingEnabled = true
+        }
+
+        var diagramHeaders = toArr(
+            document.getElementsByClassName("diagramHeader")
+        )
+        diagramHeaders.forEach(function(header) {
+            header.addEventListener(
+                "mouseover",
+                toggleNonTerminalUsageAndDef_fromHeader
+            )
+            header.addEventListener(
+                "mouseout",
+                toggleNonTerminalUsageAndDef_fromHeader
+            )
+        })
+
+        var noneTerminals = toArr(
+            document.getElementsByClassName("non-terminal")
+        )
+        var noneTerminalsText = findDomChildrenByTagName(noneTerminals, "text")
+        noneTerminalsText.forEach(function(nonTerminal) {
+            nonTerminal.addEventListener(
+                "mouseover",
+                toggleNonTerminalUsageAndDef_fromNoneTerminal
+            )
+            nonTerminal.addEventListener(
+                "mouseout",
+                toggleNonTerminalUsageAndDef_fromNoneTerminal
+            )
+
+            if (scrollingEnabled) {
+                nonTerminal.addEventListener("click", jumpToNoneTerminalDef)
+            }
+        })
+
+        var terminals = toArr(document.getElementsByClassName("terminal"))
+        var terminalsText = findDomChildrenByTagName(terminals, "text")
+        terminalsText.forEach(function(terminal) {
+            terminal.addEventListener("mouseover", toggleTerminalUsage)
+            terminal.addEventListener("mouseout", toggleTerminalUsage)
+        })
+    }
+
+    function toggleTerminalUsage(mouseEvent) {
+        var terminalName = mouseEvent.target.getAttribute("label")
+        var rects = getUsageSvgRect(terminalName, "terminal", "label")
+        toggleClassForNodes(rects, "diagramRectUsage")
+    }
+
+    function toggleNonTerminalUsageAndDef_fromNoneTerminal(mouseEvent) {
+        var rectsHeaderAndRuleName = getUsageRectAndDefHeader(mouseEvent.target)
+        toggleClassForNodes(rectsHeaderAndRuleName.rects, "diagramRectUsage")
+        toggleClass(rectsHeaderAndRuleName.header, "diagramHeaderDef")
+    }
+
+    function jumpToNoneTerminalDef(mouseEvent) {
+        var header = findHeader(mouseEvent.target.getAttribute("rulename"))
+        scrollToY(header.offsetTop, 666, "easeInOutQuint")
+    }
+
+    function toggleNonTerminalUsageAndDef_fromHeader(mouseEvent) {
+        toggleClass(mouseEvent.target, "diagramHeaderDef")
+        // this does not work on an svg DOM element so its ok to use innerHTML.
+        var definitionName = mouseEvent.target.innerHTML
+        var rects = getUsageSvgRect(definitionName, "non-terminal", "rulename")
+        toggleClassForNodes(rects, "diagramRectUsage")
+    }
+
+    function getUsageSvgRect(definitionName, className, attributeName) {
+        var classDomElements = toArr(document.getElementsByClassName(className))
+        var rects = findDomChildrenByTagName(classDomElements, "rect")
+        return rects.filter(function(currRect) {
+            var textNode = currRect.parentNode.getElementsByTagName("text")[0]
+            return textNode.getAttribute(attributeName) === definitionName
+        })
+    }
+
+    function findHeader(headerName) {
+        var headers = toArr(document.getElementsByClassName("diagramHeader"))
+        var header = headers.find(function(currHeader) {
+            // this works on H2 dom elements and not SVG elements so innerHTML usage is safe.
+            return currHeader.innerHTML === headerName
+        })
+        return header
+    }
+
+    function getUsageRectAndDefHeader(target) {
+        var headerName = target.getAttribute("rulename")
+        var rects = getUsageSvgRect(headerName, "non-terminal", "rulename")
+        var header = findHeader(headerName)
+        return {
+            rects: rects,
+            header: header,
+            ruleName: headerName
+        }
+    }
+
+    // utils
+
+    // IE 10/11 does not support this on svg elements.
+    // I'm uncertain I really care... :)
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/classList
+    function toggleClass(domNode, className) {
+        if (domNode.classList.contains(className)) {
+            domNode.classList.remove(className)
+        } else {
+            domNode.classList.add(className)
+        }
+    }
+
+    function toggleClassForNodes(domNodes, className) {
+        domNodes.forEach(function(currDomNode) {
+            toggleClass(currDomNode, className)
+        })
+    }
+
+    function toArr(htmlCollection) {
+        return Array.prototype.slice.call(htmlCollection)
+    }
+
+    // first add raf shim
+    // http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
+    var requestAnimFrame = (function() {
+        return (
+            window.requestAnimationFrame ||
+            window.webkitRequestAnimationFrame ||
+            window.mozRequestAnimationFrame ||
+            function(callback) {
+                window.setTimeout(callback, 1000 / 60)
+            }
+        )
+    })()
+
+    // https://stackoverflow.com/questions/8917921/cross-browser-javascript-not-jquery-scroll-to-top-animation
+    function scrollToY(scrollTargetY, speed, easing) {
+        // scrollTargetY: the target scrollY property of the window
+        // speed: time in pixels per second
+        // easing: easing equation to use
+
+        var scrollY = window.scrollY,
+            scrollTargetY = scrollTargetY || 0,
+            speed = speed || 2000,
+            easing = easing || "easeOutSine",
+            currentTime = 0
+
+        // min time .1, max time .8 seconds
+        var time = Math.max(
+            0.1,
+            Math.min(Math.abs(scrollY - scrollTargetY) / speed, 0.8)
+        )
+
+        // easing equations from https://github.com/danro/easing-js/blob/master/easing.js
+        var PI_D2 = Math.PI / 2,
+            easingEquations = {
+                easeOutSine: function(pos) {
+                    return Math.sin(pos * (Math.PI / 2))
+                },
+                easeInOutSine: function(pos) {
+                    return -0.5 * (Math.cos(Math.PI * pos) - 1)
+                },
+                easeInOutQuint: function(pos) {
+                    if ((pos /= 0.5) < 1) {
+                        return 0.5 * Math.pow(pos, 5)
+                    }
+                    return 0.5 * (Math.pow(pos - 2, 5) + 2)
+                }
+            }
+
+        // add animation loop
+        function tick() {
+            currentTime += 1 / 60
+
+            var p = currentTime / time
+            var t = easingEquations[easing](p)
+
+            if (p < 1) {
+                requestAnimFrame(tick)
+
+                window.scrollTo(0, scrollY + (scrollTargetY - scrollY) * t)
+            } else {
+                window.scrollTo(0, scrollTargetY)
+            }
+        }
+
+        // call it once to get started
+        tick()
+    }
+
+    function findDomChildrenByTagName(domElements, tagName) {
+        var elemsFound = []
+        domElements.forEach(function(currDomNode) {
+            toArr(currDomNode.children).forEach(function(currChild) {
+                if (currChild.tagName === tagName) {
+                    elemsFound.push(currChild)
+                }
+            })
+        })
+        return elemsFound
+    }
+    return {
+        initDiagramsBehavior: initDiagramsBehavior
+    }
+})

package/packages/css-parser/node_modules/chevrotain/diagrams/src/diagrams_builder.js

@@ -0,0 +1,211 @@
+;(function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+        // AMD. Register as an anonymous module.
+        // TODO: remove dependency to Chevrotain
+        define(["../vendor/railroad-diagrams"], factory)
+    } else if (typeof module === "object" && module.exports) {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like environments that support module.exports,
+        // like Node.
+        // TODO: remove dependency to Chevrotain
+        module.exports = factory(require("../vendor/railroad-diagrams"))
+    } else {
+        // Browser globals (root is window)
+        root.diagrams_builder = factory(root.railroad)
+    }
+})(this, function(railroad) {
+    var Diagram = railroad.Diagram
+    var Sequence = railroad.Sequence
+    var Choice = railroad.Choice
+    var Optional = railroad.Optional
+    var OneOrMore = railroad.OneOrMore
+    var ZeroOrMore = railroad.ZeroOrMore
+    var Terminal = railroad.Terminal
+    var NonTerminal = railroad.NonTerminal
+
+    /**
+     * @param {chevrotain.gast.ISerializedGast} topRules
+     *
+     * @returns {string} - The htmlText that will render the diagrams
+     */
+    function buildSyntaxDiagramsText(topRules) {
+        var diagramsHtml = ""
+
+        topRules.forEach(function(production) {
+            var currDiagramHtml = convertProductionToDiagram(
+                production,
+                production.name
+            )
+            diagramsHtml +=
+                '<h2 class="diagramHeader">' +
+                production.name +
+                "</h2>" +
+                currDiagramHtml
+        })
+
+        return diagramsHtml
+    }
+
+    function definitionsToSubDiagrams(definitions, topRuleName) {
+        var subDiagrams = definitions.map(function(subProd) {
+            return convertProductionToDiagram(subProd, topRuleName)
+        })
+        return subDiagrams
+    }
+
+    /**
+     * @param {chevrotain.gast.ISerializedTerminal} prod
+     * @param {string} topRuleName
+     * @param {string} dslRuleName
+     *
+     * @return {RailRoadDiagram.Terminal}
+     */
+    function createTerminalFromSerializedGast(prod, topRuleName, dslRuleName) {
+        // PATTERN static property will not exist when using custom lexers (hand built or other lexer generators)
+        var toolTipTitle = undefined
+        // avoid trying to use a custom token pattern as the title.
+        if (
+            typeof prod.pattern === "string" ||
+            Object.prototype.toString.call(prod.pattern) === "[object RegExp]"
+        ) {
+            toolTipTitle = prod.pattern
+        }
+
+        return railroad.Terminal(
+            prod.label,
+            undefined,
+            toolTipTitle,
+            prod.occurrenceInParent,
+            topRuleName,
+            dslRuleName,
+            prod.name
+        )
+    }
+
+    /**
+     * @param prod
+     * @param topRuleName
+     *
+     * Converts a single Chevrotain Grammar production to a RailRoad Diagram.
+     * This is also exported to allow custom logic in the creation of the diagrams.
+     * @returns {*}
+     */
+    function convertProductionToDiagram(prod, topRuleName) {
+        if (prod.type === "NonTerminal") {
+            // must handle NonTerminal separately from the other AbstractProductions as we do not want to expand the subDefinition
+            // of a reference and cause infinite loops
+            return NonTerminal(
+                getNonTerminalName(prod),
+                undefined,
+                prod.occurrenceInParent,
+                topRuleName
+            )
+        } else if (prod.type !== "Terminal") {
+            var subDiagrams = definitionsToSubDiagrams(
+                prod.definition,
+                topRuleName
+            )
+            if (prod.type === "Rule") {
+                return Diagram.apply(this, subDiagrams)
+            } else if (prod.type === "Flat") {
+                return Sequence.apply(this, subDiagrams)
+            } else if (prod.type === "Option") {
+                if (subDiagrams.length > 1) {
+                    return Optional(Sequence.apply(this, subDiagrams))
+                } else if (subDiagrams.length === 1) {
+                    return Optional(subDiagrams[0])
+                } else {
+                    throw Error("Empty Optional production, OOPS!")
+                }
+            } else if (prod.type === "Repetition") {
+                if (subDiagrams.length > 1) {
+                    return ZeroOrMore(Sequence.apply(this, subDiagrams))
+                } else if (subDiagrams.length === 1) {
+                    return ZeroOrMore(subDiagrams[0])
+                } else {
+                    throw Error("Empty Optional production, OOPS!")
+                }
+            } else if (prod.type === "Alternation") {
+                // todo: what does the first argument of choice (the index 0 means?)
+                return Choice.apply(this, [0].concat(subDiagrams))
+            } else if (prod.type === "RepetitionMandatory") {
+                if (subDiagrams.length > 1) {
+                    return OneOrMore(Sequence.apply(this, subDiagrams))
+                } else if (subDiagrams.length === 1) {
+                    return OneOrMore(subDiagrams[0])
+                } else {
+                    throw Error("Empty Optional production, OOPS!")
+                }
+            } else if (prod.type === "RepetitionWithSeparator") {
+                if (subDiagrams.length > 0) {
+                    // MANY_SEP(separator, definition) === (definition (separator definition)*)?
+                    return Optional(
+                        Sequence.apply(
+                            this,
+                            subDiagrams.concat([
+                                ZeroOrMore(
+                                    Sequence.apply(
+                                        this,
+                                        [
+                                            createTerminalFromSerializedGast(
+                                                prod.separator,
+                                                topRuleName,
+                                                "many_sep"
+                                            )
+                                        ].concat(subDiagrams)
+                                    )
+                                )
+                            ])
+                        )
+                    )
+                } else {
+                    throw Error("Empty Optional production, OOPS!")
+                }
+            } else if (prod.type === "RepetitionMandatoryWithSeparator") {
+                if (subDiagrams.length > 0) {
+                    // AT_LEAST_ONE_SEP(separator, definition) === definition (separator definition)*
+                    return Sequence.apply(
+                        this,
+                        subDiagrams.concat([
+                            ZeroOrMore(
+                                Sequence.apply(
+                                    this,
+                                    [
+                                        createTerminalFromSerializedGast(
+                                            prod.separator,
+                                            topRuleName,
+                                            "at_least_one_sep"
+                                        )
+                                    ].concat(subDiagrams)
+                                )
+                            )
+                        ])
+                    )
+                } else {
+                    throw Error("Empty Optional production, OOPS!")
+                }
+            }
+        } else if (prod.type === "Terminal") {
+            return createTerminalFromSerializedGast(
+                prod,
+                topRuleName,
+                "consume"
+            )
+        } else {
+            throw Error("non exhaustive match")
+        }
+    }
+
+    function getNonTerminalName(prod) {
+        if (prod.nonTerminalName !== undefined) {
+            return prod.nonTerminalName
+        } else {
+            return prod.name
+        }
+    }
+
+    return {
+        buildSyntaxDiagramsText: buildSyntaxDiagramsText,
+        convertProductionToDiagram: convertProductionToDiagram
+    }
+})

package/packages/css-parser/node_modules/chevrotain/diagrams/src/diagrams_serializer.js

@@ -0,0 +1,20 @@
+/**
+ * @param {string} targetFilePath - The path and file name to serialize to.
+ * @param {string} varName - The name of the global variable to expose the serialized contents/
+ * @param {chevrotain.Parser} parserInstance - A parser instance whose grammar will be serialized.
+ */
+function serializeGrammarToFile(targetFilePath, varName, parserInstance) {
+    var fs = require("fs")
+    var serializedGrammar = parserInstance.getSerializedGastProductions()
+    var serializedGrammarText = JSON.stringify(serializedGrammar, null, "\t")
+
+    // generated a JavaScript file which exports the serialized grammar on the global scope (Window)
+    fs.writeFileSync(
+        targetFilePath,
+        "var " + varName + " = " + serializedGrammarText
+    )
+}
+
+module.exports = {
+    serializeGrammarToFile: serializeGrammarToFile
+}

package/packages/css-parser/node_modules/chevrotain/diagrams/src/main.js

@@ -0,0 +1,38 @@
+;(function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(["./diagrams_builder", "./diagrams_behavior"], factory)
+    } else if (typeof module === "object" && module.exports) {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like environments that support module.exports,
+        // like Node.
+        module.exports = factory(
+            require("./diagrams_builder"),
+            require("./diagrams_behavior")
+        )
+    } else {
+        // Browser globals (root is window)
+        root.main = factory(root.diagrams_builder, root.diagrams_behavior)
+    }
+})(this, function(builder, behavior) {
+    return {
+        drawDiagramsFromParserInstance: function(
+            parserInstanceToDraw,
+            targetDiv
+        ) {
+            var topRules = parserInstanceToDraw.getSerializedGastProductions()
+            targetDiv.innerHTML = builder.buildSyntaxDiagramsText(topRules)
+            behavior.initDiagramsBehavior()
+        },
+
+        drawDiagramsFromSerializedGrammar: function(
+            serializedGrammar,
+            targetDiv
+        ) {
+            targetDiv.innerHTML = builder.buildSyntaxDiagramsText(
+                serializedGrammar
+            )
+            behavior.initDiagramsBehavior()
+        }
+    }
+})