tuiuiu.js 0.1.1

package/dist/styling/parser.js

@@ -0,0 +1,901 @@
+/**
+ * TCSS Parser
+ *
+ * Recursive descent parser for TCSS (Terminal CSS).
+ * Converts tokens from the tokenizer into an Abstract Syntax Tree (AST).
+ */
+import { TokenType, tokenize } from './tokenizer.js';
+// =============================================================================
+// Parser Class
+// =============================================================================
+export class Parser {
+    tokens = [];
+    current = 0;
+    errors = [];
+    options;
+    constructor(options = {}) {
+        this.options = {
+            tolerant: options.tolerant ?? true,
+        };
+    }
+    /**
+     * Parse TCSS source into AST
+     */
+    parse(source) {
+        this.tokens = tokenize(source);
+        this.current = 0;
+        this.errors = [];
+        const ast = this.parseStylesheet();
+        return { ast, errors: this.errors };
+    }
+    /**
+     * Parse from tokens directly
+     */
+    parseTokens(tokens) {
+        this.tokens = tokens;
+        this.current = 0;
+        this.errors = [];
+        const ast = this.parseStylesheet();
+        return { ast, errors: this.errors };
+    }
+    // ===========================================================================
+    // Utility Methods
+    // ===========================================================================
+    peek() {
+        return this.tokens[this.current];
+    }
+    peekNext() {
+        return this.tokens[this.current + 1];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.current++;
+        }
+        return this.previous();
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    checkValue(type, value) {
+        if (this.isAtEnd())
+            return false;
+        const token = this.peek();
+        return token.type === type && token.value === value;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    consume(type, message) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        throw this.error(message);
+    }
+    error(message) {
+        const token = this.peek();
+        const error = {
+            message,
+            line: token.line,
+            column: token.column,
+            token,
+        };
+        this.errors.push(error);
+        return error;
+    }
+    synchronize() {
+        this.advance();
+        while (!this.isAtEnd()) {
+            // Stop at statement boundaries
+            if (this.previous().type === TokenType.RBRACE)
+                return;
+            if (this.previous().type === TokenType.SEMICOLON)
+                return;
+            switch (this.peek().type) {
+                case TokenType.AT_KEYWORD:
+                case TokenType.VARIABLE:
+                case TokenType.IDENT:
+                case TokenType.DOT:
+                case TokenType.HASH:
+                case TokenType.STAR:
+                    return;
+            }
+            this.advance();
+        }
+    }
+    // ===========================================================================
+    // Parsing Methods
+    // ===========================================================================
+    parseStylesheet() {
+        const startToken = this.peek();
+        const rules = [];
+        while (!this.isAtEnd()) {
+            try {
+                const rule = this.parseTopLevel();
+                if (rule) {
+                    rules.push(rule);
+                }
+            }
+            catch {
+                if (this.options.tolerant) {
+                    this.synchronize();
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return {
+            type: 'stylesheet',
+            rules,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseTopLevel() {
+        // Skip any stray semicolons
+        while (this.match(TokenType.SEMICOLON)) { }
+        if (this.isAtEnd())
+            return null;
+        // @import
+        if (this.check(TokenType.AT_KEYWORD) && this.peek().value === '@import') {
+            return this.parseImport();
+        }
+        // @media
+        if (this.check(TokenType.AT_KEYWORD) && this.peek().value === '@media') {
+            return this.parseMedia();
+        }
+        // Variable definition
+        if (this.check(TokenType.VARIABLE)) {
+            return this.parseVariableDefinition();
+        }
+        // Rule
+        return this.parseRule();
+    }
+    parseImport() {
+        const startToken = this.advance(); // consume @import
+        // Expect a string
+        const pathToken = this.consume(TokenType.STRING, 'Expected import path string');
+        // Optional semicolon
+        this.match(TokenType.SEMICOLON);
+        return {
+            type: 'import',
+            path: pathToken.value,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseMedia() {
+        const startToken = this.advance(); // consume @media
+        // Parse media conditions
+        const conditions = [];
+        // Expect opening paren for condition
+        if (this.match(TokenType.LPAREN)) {
+            conditions.push(this.parseMediaCondition());
+            this.consume(TokenType.RPAREN, 'Expected ) after media condition');
+            // Handle additional conditions with 'and'
+            while (this.check(TokenType.IDENT) && this.peek().value === 'and') {
+                this.advance(); // consume 'and'
+                this.consume(TokenType.LPAREN, 'Expected ( after "and"');
+                conditions.push(this.parseMediaCondition());
+                this.consume(TokenType.RPAREN, 'Expected ) after media condition');
+            }
+        }
+        // Expect opening brace
+        this.consume(TokenType.LBRACE, 'Expected { after media query');
+        // Parse rules inside media
+        const rules = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            try {
+                if (this.check(TokenType.VARIABLE)) {
+                    rules.push(this.parseVariableDefinition());
+                }
+                else {
+                    rules.push(this.parseRule());
+                }
+            }
+            catch {
+                if (this.options.tolerant) {
+                    this.synchronize();
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        this.consume(TokenType.RBRACE, 'Expected } after media rules');
+        return {
+            type: 'media',
+            conditions,
+            rules,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseMediaCondition() {
+        const startToken = this.peek();
+        // Feature name (e.g., min-width)
+        const featureToken = this.consume(TokenType.IDENT, 'Expected media feature name');
+        let value;
+        // Check for colon + value
+        if (this.match(TokenType.COLON)) {
+            value = this.parseValue();
+        }
+        return {
+            type: 'media-condition',
+            feature: featureToken.value,
+            value,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseVariableDefinition() {
+        const startToken = this.advance(); // consume $variable
+        this.consume(TokenType.COLON, 'Expected : after variable name');
+        const values = this.parseValueList();
+        // Optional semicolon
+        this.match(TokenType.SEMICOLON);
+        return {
+            type: 'variable-definition',
+            name: startToken.value,
+            values,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseRule() {
+        const startToken = this.peek();
+        // Parse selectors
+        const selectors = this.parseSelectorList();
+        // Expect opening brace
+        this.consume(TokenType.LBRACE, 'Expected { after selector');
+        // Parse declarations
+        const declarations = this.parseDeclarations();
+        // Expect closing brace
+        this.consume(TokenType.RBRACE, 'Expected } after declarations');
+        return {
+            type: 'rule',
+            selectors,
+            declarations,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseSelectorList() {
+        const startToken = this.peek();
+        const selectors = [];
+        selectors.push(this.parseComplexSelector());
+        while (this.match(TokenType.COMMA)) {
+            selectors.push(this.parseComplexSelector());
+        }
+        return {
+            type: 'selector-list',
+            selectors,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseComplexSelector() {
+        let left = this.parseCompoundSelector();
+        while (true) {
+            const combinator = this.parseCombinator();
+            if (!combinator)
+                break;
+            const right = this.parseCompoundSelector();
+            left = {
+                type: 'complex-selector',
+                left,
+                combinator,
+                right,
+                line: left.line,
+                column: left.column,
+            };
+        }
+        return left;
+    }
+    parseCombinator() {
+        // Check for explicit combinators
+        if (this.match(TokenType.GREATER)) {
+            return 'child';
+        }
+        if (this.match(TokenType.PLUS)) {
+            return 'adjacent';
+        }
+        if (this.match(TokenType.TILDE)) {
+            return 'sibling';
+        }
+        // Check for descendant combinator (implicit - space between selectors)
+        // We need to check if next token can start a selector
+        if (this.canStartSelector()) {
+            return 'descendant';
+        }
+        return null;
+    }
+    canStartSelector() {
+        const type = this.peek().type;
+        return (type === TokenType.IDENT ||
+            type === TokenType.DOT ||
+            type === TokenType.HASH ||
+            type === TokenType.STAR ||
+            type === TokenType.COLON ||
+            type === TokenType.DOUBLE_COLON ||
+            type === TokenType.LBRACKET);
+    }
+    parseCompoundSelector() {
+        const startToken = this.peek();
+        const selectors = [];
+        // First selector can be IDENT, STAR, or any other selector starter
+        if (this.canStartSimpleSelector()) {
+            selectors.push(this.parseSimpleSelector());
+        }
+        // Subsequent selectors can only be class, id, pseudo, attribute
+        // (not type or universal - those would indicate a new selector with descendant combinator)
+        while (this.canContinueCompoundSelector()) {
+            selectors.push(this.parseSimpleSelector());
+        }
+        if (selectors.length === 0) {
+            throw this.error('Expected selector');
+        }
+        return {
+            type: 'compound-selector',
+            selectors,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    canStartSimpleSelector() {
+        const type = this.peek().type;
+        return (type === TokenType.IDENT ||
+            type === TokenType.DOT ||
+            type === TokenType.HASH ||
+            type === TokenType.STAR ||
+            type === TokenType.COLON ||
+            type === TokenType.DOUBLE_COLON ||
+            type === TokenType.LBRACKET);
+    }
+    /**
+     * Check if current token can continue a compound selector.
+     * Unlike canStartSimpleSelector, this excludes IDENT and STAR
+     * because those would indicate a new selector (descendant combinator).
+     */
+    canContinueCompoundSelector() {
+        const type = this.peek().type;
+        return (type === TokenType.DOT ||
+            type === TokenType.HASH ||
+            type === TokenType.COLON ||
+            type === TokenType.DOUBLE_COLON ||
+            type === TokenType.LBRACKET);
+    }
+    parseSimpleSelector() {
+        const startToken = this.peek();
+        // Universal selector: *
+        if (this.match(TokenType.STAR)) {
+            return {
+                type: 'simple-selector',
+                selectorType: 'universal',
+                name: '*',
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Type selector: Box, Text
+        if (this.check(TokenType.IDENT)) {
+            const token = this.advance();
+            return {
+                type: 'simple-selector',
+                selectorType: 'type',
+                name: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Class selector: .primary
+        if (this.match(TokenType.DOT)) {
+            const ident = this.consume(TokenType.IDENT, 'Expected class name after .');
+            return {
+                type: 'simple-selector',
+                selectorType: 'class',
+                name: ident.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // ID selector: #header (hash token includes the name)
+        if (this.check(TokenType.HASH)) {
+            const token = this.advance();
+            // Hash token value is like '#header', remove the #
+            const name = token.value.startsWith('#') ? token.value.slice(1) : token.value;
+            return {
+                type: 'simple-selector',
+                selectorType: 'id',
+                name,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Pseudo-element: ::before
+        if (this.match(TokenType.DOUBLE_COLON)) {
+            const ident = this.consume(TokenType.IDENT, 'Expected pseudo-element name after ::');
+            let argument;
+            // Check for function-like pseudo-element
+            if (this.match(TokenType.LPAREN)) {
+                argument = this.parseArgumentString();
+                this.consume(TokenType.RPAREN, 'Expected ) after pseudo-element argument');
+            }
+            return {
+                type: 'simple-selector',
+                selectorType: 'pseudo-element',
+                name: ident.value,
+                argument,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Pseudo-class: :focus, :hover, :not(), :nth-child()
+        if (this.match(TokenType.COLON)) {
+            let name;
+            let argument;
+            // Check for function-like pseudo-class (tokenizer creates FUNCTION token for name()
+            if (this.check(TokenType.FUNCTION)) {
+                const func = this.advance();
+                // Function token value is like 'nth-child(' - extract name
+                name = func.value.slice(0, -1);
+                // Parse arguments
+                argument = this.parseArgumentString();
+                this.consume(TokenType.RPAREN, 'Expected ) after pseudo-class argument');
+            }
+            else {
+                const ident = this.consume(TokenType.IDENT, 'Expected pseudo-class name after :');
+                name = ident.value;
+                // Check for function-like pseudo-class with separate LPAREN
+                if (this.match(TokenType.LPAREN)) {
+                    argument = this.parseArgumentString();
+                    this.consume(TokenType.RPAREN, 'Expected ) after pseudo-class argument');
+                }
+            }
+            return {
+                type: 'simple-selector',
+                selectorType: 'pseudo-class',
+                name,
+                argument,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Attribute selector: [attr=value]
+        if (this.match(TokenType.LBRACKET)) {
+            const attr = this.parseAttributeSelector();
+            this.consume(TokenType.RBRACKET, 'Expected ] after attribute selector');
+            return {
+                type: 'simple-selector',
+                selectorType: 'attribute',
+                name: attr.name,
+                argument: attr.argument,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        throw this.error('Expected selector');
+    }
+    parseArgumentString() {
+        // Collect tokens until closing paren
+        const parts = [];
+        let depth = 1;
+        while (!this.isAtEnd() && depth > 0) {
+            if (this.check(TokenType.LPAREN)) {
+                depth++;
+                parts.push(this.advance().value);
+            }
+            else if (this.check(TokenType.RPAREN)) {
+                depth--;
+                if (depth > 0) {
+                    parts.push(this.advance().value);
+                }
+            }
+            else {
+                parts.push(this.advance().value);
+            }
+        }
+        return parts.join(' ').trim();
+    }
+    parseAttributeSelector() {
+        const attrName = this.consume(TokenType.IDENT, 'Expected attribute name');
+        // Check for operator
+        if (this.check(TokenType.IDENT) ||
+            this.check(TokenType.STRING) ||
+            this.check(TokenType.NUMBER)) {
+            // Simple [attr value] - this is wrong, need operator
+            throw this.error('Expected attribute operator (=, ~=, |=, ^=, $=, *=)');
+        }
+        // Check for = or other operators
+        // For now, just handle simple [attr] or [attr=value]
+        if (this.peek().value === '=' || this.peek().value.endsWith('=')) {
+            this.advance(); // consume operator
+            // Get value
+            if (this.check(TokenType.STRING)) {
+                const val = this.advance();
+                return { name: attrName.value, argument: val.value };
+            }
+            else if (this.check(TokenType.IDENT)) {
+                const val = this.advance();
+                return { name: attrName.value, argument: val.value };
+            }
+        }
+        return { name: attrName.value };
+    }
+    parseDeclarations() {
+        const declarations = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            try {
+                const decl = this.parseDeclaration();
+                if (decl) {
+                    declarations.push(decl);
+                }
+            }
+            catch {
+                if (this.options.tolerant) {
+                    // Skip to next semicolon or closing brace
+                    while (!this.isAtEnd() &&
+                        !this.check(TokenType.SEMICOLON) &&
+                        !this.check(TokenType.RBRACE)) {
+                        this.advance();
+                    }
+                    this.match(TokenType.SEMICOLON);
+                }
+                else {
+                    throw this.errors[this.errors.length - 1];
+                }
+            }
+        }
+        return declarations;
+    }
+    parseDeclaration() {
+        // Skip any stray semicolons
+        while (this.match(TokenType.SEMICOLON)) { }
+        if (this.check(TokenType.RBRACE) || this.isAtEnd()) {
+            return null;
+        }
+        const startToken = this.peek();
+        // Property name
+        const propertyToken = this.consume(TokenType.IDENT, 'Expected property name');
+        this.consume(TokenType.COLON, 'Expected : after property name');
+        // Values
+        const values = this.parseValueList();
+        // Check for !important
+        let important = false;
+        if (this.match(TokenType.IMPORTANT)) {
+            important = true;
+        }
+        // Optional semicolon
+        this.match(TokenType.SEMICOLON);
+        return {
+            type: 'declaration',
+            property: propertyToken.value,
+            values,
+            important,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+    parseValueList() {
+        const values = [];
+        while (!this.isValueListEnd()) {
+            values.push(this.parseValue());
+        }
+        if (values.length === 0) {
+            throw this.error('Expected value');
+        }
+        return values;
+    }
+    isValueListEnd() {
+        return (this.isAtEnd() ||
+            this.check(TokenType.SEMICOLON) ||
+            this.check(TokenType.RBRACE) ||
+            this.check(TokenType.IMPORTANT));
+    }
+    parseValue() {
+        const startToken = this.peek();
+        // Variable reference
+        if (this.check(TokenType.VARIABLE)) {
+            const token = this.advance();
+            return {
+                type: 'value',
+                valueType: 'variable',
+                value: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Function
+        if (this.check(TokenType.FUNCTION)) {
+            return this.parseFunctionValue();
+        }
+        // Hex color
+        if (this.check(TokenType.HEX_COLOR)) {
+            const token = this.advance();
+            return {
+                type: 'value',
+                valueType: 'color',
+                value: '#' + token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // String
+        if (this.check(TokenType.STRING)) {
+            const token = this.advance();
+            return {
+                type: 'value',
+                valueType: 'string',
+                value: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Number
+        if (this.check(TokenType.NUMBER)) {
+            const token = this.advance();
+            return {
+                type: 'value',
+                valueType: 'number',
+                value: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Percentage
+        if (this.check(TokenType.PERCENTAGE)) {
+            const token = this.advance();
+            // Extract number and %
+            const num = token.value.replace('%', '');
+            return {
+                type: 'value',
+                valueType: 'percentage',
+                value: num,
+                unit: '%',
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Dimension (number with unit)
+        if (this.check(TokenType.DIMENSION)) {
+            const token = this.advance();
+            // Extract number and unit
+            const match = token.value.match(/^(-?[\d.]+)([a-zA-Z%]+)$/);
+            if (match) {
+                return {
+                    type: 'value',
+                    valueType: 'dimension',
+                    value: match[1],
+                    unit: match[2],
+                    line: startToken.line,
+                    column: startToken.column,
+                };
+            }
+            return {
+                type: 'value',
+                valueType: 'dimension',
+                value: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Keyword (identifier)
+        if (this.check(TokenType.IDENT)) {
+            const token = this.advance();
+            return {
+                type: 'value',
+                valueType: 'keyword',
+                value: token.value,
+                line: startToken.line,
+                column: startToken.column,
+            };
+        }
+        // Comma (for multi-value properties)
+        if (this.check(TokenType.COMMA)) {
+            this.advance();
+            return this.parseValue();
+        }
+        throw this.error(`Unexpected token: ${this.peek().value}`);
+    }
+    parseFunctionValue() {
+        const startToken = this.peek();
+        const token = this.advance(); // consume function token (includes opening paren)
+        // Function name is the value without the trailing (
+        const name = token.value.slice(0, -1);
+        // Parse arguments
+        const args = [];
+        while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
+            args.push(this.parseValue());
+            // Allow commas between arguments
+            this.match(TokenType.COMMA);
+        }
+        this.consume(TokenType.RPAREN, 'Expected ) after function arguments');
+        return {
+            type: 'value',
+            valueType: 'function',
+            value: name,
+            arguments: args,
+            line: startToken.line,
+            column: startToken.column,
+        };
+    }
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+/**
+ * Parse TCSS source into AST
+ */
+export function parse(source, options) {
+    const parser = new Parser(options);
+    return parser.parse(source);
+}
+/**
+ * Parse TCSS and throw on errors
+ */
+export function parseStrict(source) {
+    const result = parse(source, { tolerant: false });
+    if (result.errors.length > 0) {
+        const err = result.errors[0];
+        throw new Error(`Parse error at line ${err.line}, column ${err.column}: ${err.message}`);
+    }
+    return result.ast;
+}
+// =============================================================================
+// AST Utilities
+// =============================================================================
+/**
+ * Visit all nodes in the AST
+ */
+export function visitAST(node, visitor, parent) {
+    visitor(node, parent);
+    switch (node.type) {
+        case 'stylesheet': {
+            const stylesheet = node;
+            for (const rule of stylesheet.rules) {
+                visitAST(rule, visitor, node);
+            }
+            break;
+        }
+        case 'rule': {
+            const rule = node;
+            visitAST(rule.selectors, visitor, node);
+            for (const decl of rule.declarations) {
+                visitAST(decl, visitor, node);
+            }
+            break;
+        }
+        case 'selector-list': {
+            const list = node;
+            for (const selector of list.selectors) {
+                visitAST(selector, visitor, node);
+            }
+            break;
+        }
+        case 'complex-selector': {
+            const complex = node;
+            visitAST(complex.left, visitor, node);
+            visitAST(complex.right, visitor, node);
+            break;
+        }
+        case 'compound-selector': {
+            const compound = node;
+            for (const selector of compound.selectors) {
+                visitAST(selector, visitor, node);
+            }
+            break;
+        }
+        case 'declaration': {
+            const decl = node;
+            for (const value of decl.values) {
+                visitAST(value, visitor, node);
+            }
+            break;
+        }
+        case 'value': {
+            const val = node;
+            if (val.arguments) {
+                for (const arg of val.arguments) {
+                    visitAST(arg, visitor, node);
+                }
+            }
+            break;
+        }
+        case 'variable-definition': {
+            const varDef = node;
+            for (const value of varDef.values) {
+                visitAST(value, visitor, node);
+            }
+            break;
+        }
+        case 'media': {
+            const media = node;
+            for (const condition of media.conditions) {
+                visitAST(condition, visitor, node);
+            }
+            for (const rule of media.rules) {
+                visitAST(rule, visitor, node);
+            }
+            break;
+        }
+        case 'media-condition': {
+            const condition = node;
+            if (condition.value) {
+                visitAST(condition.value, visitor, node);
+            }
+            break;
+        }
+        // Leaf nodes: simple-selector, import
+        default:
+            break;
+    }
+}
+/**
+ * Stringify selector for debugging
+ */
+export function stringifySelector(selector) {
+    if (selector.type === 'compound-selector') {
+        return selector.selectors
+            .map(s => {
+            switch (s.selectorType) {
+                case 'type':
+                    return s.name;
+                case 'class':
+                    return '.' + s.name;
+                case 'id':
+                    return '#' + s.name;
+                case 'universal':
+                    return '*';
+                case 'pseudo-class':
+                    return ':' + s.name + (s.argument ? `(${s.argument})` : '');
+                case 'pseudo-element':
+                    return '::' + s.name + (s.argument ? `(${s.argument})` : '');
+                case 'attribute':
+                    return '[' + s.name + (s.argument ? `="${s.argument}"` : '') + ']';
+                default:
+                    return s.name;
+            }
+        })
+            .join('');
+    }
+    const combinatorMap = {
+        descendant: ' ',
+        child: ' > ',
+        adjacent: ' + ',
+        sibling: ' ~ ',
+    };
+    return (stringifySelector(selector.left) +
+        combinatorMap[selector.combinator] +
+        stringifySelector(selector.right));
+}
+/**
+ * Stringify value for debugging
+ */
+export function stringifyValue(value) {
+    switch (value.valueType) {
+        case 'function':
+            return value.value + '(' + (value.arguments?.map(stringifyValue).join(', ') ?? '') + ')';
+        case 'dimension':
+        case 'percentage':
+            return value.value + (value.unit ?? '');
+        case 'string':
+            return `"${value.value}"`;
+        default:
+            return value.value;
+    }
+}
+//# sourceMappingURL=parser.js.map