@jesscss/less-parser 1.0.6-alpha.0 → 2.0.0-alpha.1

package/lib/productions/root.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chevrotain_1 = require("chevrotain");
-function default_1($) {
-    $.rule = $.OVERRIDE_RULE('rule', () => {
-        const children = [$._(0)];
-        const rule = $.OR([
-            { ALT: () => $.SUBRULE($.atRule) },
-            { ALT: () => $.SUBRULE($.customDeclaration) },
-            {
-                GATE: $.BACKTRACK($.testMixin),
-                ALT: () => $.SUBRULE($.mixin)
-            },
-            {
-                GATE: $.BACKTRACK($.testQualifiedRule),
-                ALT: () => $.SUBRULE($.qualifiedRule)
-            },
-            { ALT: () => $.SUBRULE2($.declaration) },
-            { ALT: () => $.SUBRULE($.function) },
-            /** Capture any isolated / redundant semi-colons */
-            { ALT: () => $.CONSUME($.T.SemiColon) },
-            { ALT: () => chevrotain_1.EMPTY_ALT }
-        ]);
-        if (rule !== chevrotain_1.EMPTY_ALT) {
-            children.push(rule);
-        }
-        return {
-            name: 'rule',
-            children
-        };
-    });
-}
-exports.default = default_1;

package/lib/productions/selectors.d.ts

@@ -1,2 +0,0 @@
-import type { LessParser } from '../lessParser';
-export default function (this: LessParser, $: LessParser): void;

package/lib/productions/selectors.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function default_1($) {
-    $.selectorList = $.OVERRIDE_RULE('selectorList', () => {
-        const children = [
-            $.SUBRULE($.complexSelector)
-        ];
-        let allExtends = $.hasExtend;
-        let guard;
-        $.OR([
-            { ALT: () => guard = $.SUBRULE($.guard) },
-            {
-                ALT: () => {
-                    $.MANY(() => {
-                        children.push({
-                            name: 'delimiter',
-                            children: [
-                                $.CONSUME($.T.Comma),
-                                $._(1)
-                            ]
-                        }, $.SUBRULE2($.complexSelector));
-                        allExtends = allExtends && $.hasExtend;
-                    });
-                }
-            }
-        ]);
-        if (guard) {
-            return {
-                name: 'selectorGuard',
-                children: [
-                    children[0],
-                    guard
-                ]
-            };
-        }
-        else if (children.length === 1) {
-            return children[0];
-        }
-        /** Determines here if can omit a curly block */
-        $.hasExtend = allExtends;
-        return {
-            name: 'selectorList',
-            children
-        };
-    });
-    $.complexSelector = $.OVERRIDE_RULE('complexSelector', () => {
-        const selectors = [];
-        $.OR([
-            { ALT: () => {
-                    selectors.push($.SUBRULE($.compoundSelector));
-                    $.MANY(() => selectors.push($.SUBRULE($.combinatorSelector)));
-                } },
-            {
-                ALT: () => $.AT_LEAST_ONE(() => selectors.push($.SUBRULE2($.combinatorSelector)))
-            }
-        ]);
-        let extend = $.OPTION(() => {
-            $.hasExtend = true;
-            return {
-                name: 'extend',
-                children: [
-                    $.CONSUME($.T.Extend),
-                    $.SUBRULE($.selectorList),
-                    $.CONSUME($.T.RParen),
-                    $._(1)
-                ]
-            };
-        });
-        return {
-            name: 'complexSelector',
-            children: [
-                {
-                    name: 'selectors',
-                    children: selectors
-                },
-                extend
-            ]
-        };
-    });
-    $.simpleSelector = $.OVERRIDE_RULE('simpleSelector', () => $.OR([
-        { ALT: () => $.SUBRULE($.pseudoSelector) },
-        { ALT: () => $.SUBRULE($.attrSelector) },
-        { ALT: () => $.SUBRULE($.nameSelector) },
-        /** Used in keyframes as a selector */
-        { ALT: () => $.CONSUME($.T.Dimension) },
-        /** Can be a partial class, as in `&-1` */
-        { ALT: () => $.CONSUME($.T.Number) }
-    ]));
-    $.attrIdent = $.OVERRIDE_RULE('attrIdent', () => $.SUBRULE($.identOrInterpolated));
-}
-exports.default = default_1;

package/lib/productions/values.d.ts

@@ -1,2 +0,0 @@
-import { LessParser } from '../lessParser';
-export default function (this: LessParser, $: LessParser): void;

package/lib/productions/values.js

@@ -1,305 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chevrotain_1 = require("chevrotain");
-function default_1($) {
-    const compareGate = () => $.inCompareBlock;
-    /**
-     * @todo - rewrite to capture all guard expressions
-     */
-    $.expression = $.OVERRIDE_RULE('expression', () => {
-        const children = [
-            $._(0)
-        ];
-        $.OR([
-            {
-                GATE: compareGate,
-                ALT: () => $.MANY(() => children.push($.SUBRULE($.compare)))
-            },
-            { ALT: () => $.MANY2(() => children.push($.SUBRULE($.addition))) }
-        ]);
-        return {
-            name: 'expression',
-            children
-        };
-    });
-    $.function = $.RULE('function', () => ({
-        name: 'function',
-        children: $.OR([
-            {
-                ALT: () => [
-                    $.OR2([
-                        { ALT: () => $.CONSUME($.T.PlainFunction) },
-                        { ALT: () => $.CONSUME($.T.FormatFunction) }
-                    ]),
-                    $.SUBRULE($.functionArgs),
-                    $.CONSUME($.T.RParen)
-                ]
-            },
-            /**
-             * Special parsing of `if` and `boolean`
-             */
-            {
-                ALT: () => [
-                    $.CONSUME($.T.BooleanFunction),
-                    $.SUBRULE($.guardOr, { ARGS: [true] }),
-                    $.CONSUME2($.T.RParen)
-                ]
-            },
-            {
-                ALT: () => {
-                    const functionArgs = [];
-                    const func = $.CONSUME($.T.IfFunction);
-                    functionArgs.push($.SUBRULE2($.guardOr, { ARGS: [true] }), $._());
-                    $.MANY(() => {
-                        functionArgs.push({
-                            name: 'delimiter',
-                            children: [
-                                $.OR3([{
-                                        ALT: () => $.CONSUME($.T.Comma)
-                                    },
-                                    { ALT: () => $.CONSUME($.T.SemiColon)
-                                    }]),
-                                $._(1)
-                            ]
-                        }, $.SUBRULE2($.functionArg), $._(2));
-                    });
-                    return [
-                        func,
-                        {
-                            name: 'functionArgs',
-                            children: functionArgs
-                        },
-                        $.CONSUME3($.T.RParen)
-                    ];
-                }
-            }
-        ])
-    }));
-    $.functionArgs = $.RULE('functionArgs', () => {
-        const children = [
-            $.SUBRULE($.functionArg),
-            $._()
-        ];
-        $.MANY(() => {
-            children.push({
-                name: 'delimiter',
-                children: [
-                    $.OR([
-                        { ALT: () => $.CONSUME($.T.Comma) },
-                        { ALT: () => $.CONSUME($.T.SemiColon)
-                        }
-                    ]),
-                    $._(1)
-                ]
-            }, $.SUBRULE2($.functionArg), $._(2));
-        });
-        return {
-            name: 'functionArgs',
-            children
-        };
-    });
-    $.functionArg = $.RULE('functionArg', () => $.OR([
-        { ALT: () => $.SUBRULE($.anonMixin) },
-        { ALT: () => $.SUBRULE($.curlyBlock) },
-        { ALT: () => $.SUBRULE($.expression) }
-    ]));
-    /**
-     * Can be in the form of:
-     *   @var
-     *   #selector()[lookup]
-     *   #selector(args)[lookup]
-     *   @var[lookup]
-     *   @var[lookup][lookup2]
-     */
-    $.variable = $.RULE('variable', () => {
-        let selectors;
-        let node = $.OR([
-            { ALT: () => ({
-                    name: 'variable',
-                    children: [$.CONSUME($.T.VarOrProp)]
-                })
-            },
-            {
-                ALT: () => {
-                    selectors = [];
-                    $.AT_LEAST_ONE(() => selectors.push($.CONSUME($.T.Selector)));
-                    const expr = {
-                        name: 'expression',
-                        children: selectors
-                    };
-                    /**
-                     * @note - if there are no parens or accessors, then
-                     *         it's a plain selector
-                     */
-                    const children = $.OPTION(() => [
-                        $.CONSUME($.T.LParen),
-                        $.SUBRULE($.mixinArgs),
-                        $.CONSUME($.T.RParen)
-                    ]);
-                    if (!this.RECORDING_PHASE && children) {
-                        return {
-                            name: 'mixinCall',
-                            children: [
-                                expr,
-                                ...children
-                            ]
-                        };
-                    }
-                    return expr;
-                }
-            }
-        ]);
-        $.MANY(() => {
-            const L = $.CONSUME($.T.LSquare);
-            let lookup = $.OR2([
-                { ALT: () => $.CONSUME2($.T.VarOrProp) },
-                { ALT: () => $.CONSUME($.T.Ident) },
-                { ALT: () => chevrotain_1.EMPTY_ALT }
-            ]);
-            const R = $.CONSUME($.T.RSquare);
-            if (lookup === chevrotain_1.EMPTY_ALT) {
-                lookup = undefined;
-            }
-            /**
-             * Nest accessors so we can evaluate inner-most first,
-             * and then successive accessors.
-             */
-            node = {
-                name: 'accessor',
-                children: [node, L, lookup, R]
-            };
-        });
-        return node;
-    });
-    $.valueBlock = $.RULE('valueBlock', () => ({
-        name: 'block',
-        children: $.OR([
-            {
-                ALT: () => [
-                    $.CONSUME($.T.LParen),
-                    $.OR2([
-                        {
-                            GATE: compareGate,
-                            ALT: () => $.SUBRULE($.guardOr)
-                        },
-                        { ALT: () => $.SUBRULE($.expressionList) }
-                    ]),
-                    $.CONSUME($.T.RParen)
-                ]
-            },
-            {
-                ALT: () => [
-                    $.CONSUME($.T.LSquare),
-                    $.SUBRULE2($.expressionList),
-                    $.CONSUME($.T.RSquare)
-                ]
-            }
-        ])
-    }));
-    /** This is more specific than the CSS parser */
-    $.value = $.OVERRIDE_RULE('value', () => {
-        let op = $.OPTION(() => 
-        /** Applying negative or positive to a value */
-        $.CONSUME($.T.AdditionOperator));
-        let value = {
-            name: 'value',
-            children: [
-                $.OR([
-                    { ALT: () => $.SUBRULE($.valueBlock) },
-                    { ALT: () => $.SUBRULE($.function) },
-                    { ALT: () => $.CONSUME($.T.Ident) },
-                    { ALT: () => $.SUBRULE($.variable) },
-                    { ALT: () => $.CONSUME($.T.CustomProperty) },
-                    { ALT: () => $.CONSUME($.T.Dimension) },
-                    { ALT: () => $.CONSUME($.T.Number) },
-                    { ALT: () => $.CONSUME($.T.Percent) },
-                    { ALT: () => $.CONSUME($.T.StringLiteral) },
-                    { ALT: () => $.CONSUME($.T.Uri) },
-                    { ALT: () => $.CONSUME($.T.ColorIntStart) },
-                    { ALT: () => $.CONSUME($.T.UnicodeRange) },
-                    { ALT: () => $.CONSUME($.T.When) },
-                    /** Can be found in selector expressions */
-                    { ALT: () => $.CONSUME($.T.AttrMatchOperator) },
-                    { ALT: () => $.CONSUME($.T.Colon) },
-                    { ALT: () => $.CONSUME($.T.Combinator) }
-                ]),
-                $._()
-            ]
-        };
-        if (op) {
-            return {
-                name: 'sign',
-                children: [
-                    op,
-                    value
-                ]
-            };
-        }
-        return value;
-    });
-    $.compare = $.RULE('compare', () => {
-        const compareValue = $.inCompareBlock;
-        $.inCompareBlock = true;
-        let expr = $.SUBRULE($.addition);
-        $.MANY(() => {
-            expr = {
-                name: 'compare',
-                children: [
-                    expr,
-                    {
-                        name: 'op',
-                        children: [
-                            $.CONSUME($.T.CompareOperator),
-                            $._(0)
-                        ]
-                    },
-                    $.SUBRULE2($.addition)
-                ]
-            };
-        });
-        /** Restore to value on entry */
-        $.inCompareBlock = compareValue;
-        return expr;
-    });
-    $.addition = $.RULE('addition', () => {
-        let expr = $.SUBRULE($.multiplication);
-        $.MANY(() => {
-            expr = {
-                name: 'addition',
-                children: [
-                    expr,
-                    {
-                        name: 'op',
-                        children: [
-                            $.CONSUME($.T.AdditionOperator),
-                            $._(0)
-                        ]
-                    },
-                    $.SUBRULE2($.multiplication)
-                ]
-            };
-        });
-        return expr;
-    });
-    $.multiplication = $.RULE('multiplication', () => {
-        let expr = $.SUBRULE($.value);
-        $.MANY(() => {
-            expr = {
-                name: 'multiplication',
-                children: [
-                    expr,
-                    {
-                        name: 'op',
-                        children: [
-                            $.CONSUME($.T.MultiplicationOperator),
-                            $._(0)
-                        ]
-                    },
-                    $.SUBRULE2($.value)
-                ]
-            };
-        });
-        return expr;
-    });
-}
-exports.default = default_1;