This project aims to implement a CSS(less like) parser in rust. Currently the code is targeting the PostCSS AST. Very early stage, do not use in production.

Related tags

Parsing css rust parser lexer
Overview

CSS(less like) parser written in rust (WIP)

This project aims to implement a CSS(less like) parser in rust. Currently the code is targeting the PostCSS AST.

Features:

Nestable CSS Standard

  • rule
  • prop
  • declaration
    • url
    • hex
    • string
    • number
    • calc
    • var
    • !important
  • at rule
    • media query
    • import
    • keyframe
    • variable
  • selector
    • block
    • class
    • id
    • data attribute
    • &
    • ,
    • +
    • *
    • sudo class
    • more W3C standard to be tested...
  • comment
  • function?

Diagnostic

  • location
  • error report

APIs

  • transformer
  • generator
  • wasm

Example

  • input
@variable: #999;

@variable2: #fff;

@variable3: white !important;

@import url();

@media only screen and (max-width: 1000px) {
    color: white;
    font-size: 10px !important;
}

main {
    * {
        font-size: 3em;
    }
    color: #999;
    -webkit-line-clamp: 3;
    h3 {
        font-size: large;
        background: url("https://www.baidu.com");
    }
    div + p {
        list-style: "|";
    }
    .test-1, #test2 {
        --theme-color: var(--white);
    }
    [data-attr] {
        background-color: white;
        left: calc(100% - 10px);
    }
    &.img {
        width: fit-content;
    }
    & {
        div {
            overflow: initial;
        }
    }
    #what {
        right: 0;
    }
}

.test-class1 {
    color: white;
}

@keyframes anim {
    from {
        left: 0%;
    }
    to {
        right: 100%;
    }
}
  • output
[
    Atrule {
        type: "atrule",
        name: "variable",
        params: "#999",
        value: Some(
            "#999",
        ),
        nodes: None,
    },
    Atrule {
        type: "atrule",
        name: "variable2",
        params: "#fff",
        value: Some(
            "#fff",
        ),
        nodes: None,
    },
    Atrule {
        type: "atrule",
        name: "variable3",
        params: "white !important",
        value: Some(
            "white !important",
        ),
        nodes: None,
    },
    Atrule {
        type: "atrule",
        name: "import",
        params: "url()",
        value: None,
        nodes: None,
    },
    Atrule {
        type: "atrule",
        name: "media",
        params: "only screen and (max-width 1000px)",
        value: None,
        nodes: Some(
            [
                Decl {
                    type: "decl",
                    prop: "color",
                    value: "white",
                    important: None,
                },
                Decl {
                    type: "decl",
                    prop: "font-size",
                    value: "10px ",
                    important: Some(
                        true,
                    ),
                },
            ],
        ),
    },
    Rule {
        type: "rule",
        selector: "main",
        nodes: [
            Rule {
                type: "rule",
                selector: "*",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "font-size",
                        value: "3em",
                        important: None,
                    },
                ],
            },
            Decl {
                type: "decl",
                prop: "color",
                value: "#999",
                important: None,
            },
            Decl {
                type: "decl",
                prop: "-webkit-line-clamp",
                value: "3",
                important: None,
            },
            Rule {
                type: "rule",
                selector: "h3",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "font-size",
                        value: "large",
                        important: None,
                    },
                    Decl {
                        type: "decl",
                        prop: "background",
                        value: "url(\"https://www.baidu.com\")",
                        important: None,
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: "div + p",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "list-style",
                        value: "\"|\"",
                        important: None,
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: ".test-1, #test2",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "--theme-color",
                        value: "var(--white)",
                        important: None,
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: "[data-attr]",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "background-color",
                        value: "white",
                        important: None,
                    },
                    Decl {
                        type: "decl",
                        prop: "left",
                        value: "calc(100% - 10px)",
                        important: None,
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: "&.img",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "width",
                        value: "fit-content",
                        important: None,
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: "&",
                nodes: [
                    Rule {
                        type: "rule",
                        selector: "div",
                        nodes: [
                            Decl {
                                type: "decl",
                                prop: "overflow",
                                value: "initial",
                                important: None,
                            },
                        ],
                    },
                ],
            },
            Rule {
                type: "rule",
                selector: "#what",
                nodes: [
                    Decl {
                        type: "decl",
                        prop: "right",
                        value: "0",
                        important: None,
                    },
                ],
            },
        ],
    },
    Rule {
        type: "rule",
        selector: ".test-class1",
        nodes: [
            Decl {
                type: "decl",
                prop: "color",
                value: "white",
                important: None,
            },
        ],
    },
    Atrule {
        type: "atrule",
        name: "keyframes",
        params: "anim",
        value: None,
        nodes: Some(
            [
                Rule {
                    type: "rule",
                    selector: "from",
                    nodes: [
                        Decl {
                            type: "decl",
                            prop: "left",
                            value: "0%",
                            important: None,
                        },
                    ],
                },
                Rule {
                    type: "rule",
                    selector: "to",
                    nodes: [
                        Decl {
                            type: "decl",
                            prop: "right",
                            value: "100%",
                            important: None,
                        },
                    ],
                },
            ],
        ),
    },
]
You might also like...
A parser combinator library for Rust

combine An implementation of parser combinators for Rust, inspired by the Haskell library Parsec. As in Parsec the parsers are LL(1) by default but th

Markus Westerlind 1.1k Dec 28, 2022
LR(1) parser generator for Rust

LALRPOP LALRPOP is a Rust parser generator framework with usability as its primary goal. You should be able to write compact, DRY, readable grammars.

null 2.4k Jan 7, 2023
Rust query string parser with nesting support

What is Queryst? This is a fork of the original, with serde and serde_json updated to 0.9 A query string parsing library for Rust inspired by https://

Stanislav Panferov 67 Nov 16, 2022
Soon to be AsciiDoc parser implemented in rust!

pagliascii "But ASCII Doc, I am Pagliascii" Soon to be AsciiDoc parser implemented in rust! This project is the current implementation of the requeste

Lukas Wirth 49 Dec 11, 2022
PEG parser for YAML written in Rust 🦀

yaml-peg PEG parser (pest) for YAML written in Rust 🦀 Quick Start ⚡️ # Run cargo run -- --file example_files/test.yaml # Output { "xmas": "true",

Visarut Phusua 4 Sep 17, 2022
MRT/BGP data parser written in Rust.
MRT/BGP data parser written in Rust.

BGPKIT Parser BGPKIT Parser aims to provides the most ergonomic MRT/BGP message parsing Rust API. BGPKIT Parser has the following features: performant

BGPKIT 46 Dec 19, 2022
A feature-few, no-allocation JSON parser in `no_std` rust.

Small JSON Parser in no_std This library reads and parses JSON strings. Its intended use case is to read a JSON payload once. It does not serialise da

Robert Spencer 18 Nov 29, 2022
A Gura parser for Rust

Gura Rust parser IMPORTANT: if you need to use Gura in a more user-friendly way, you have at your disposal Serde Gura which allows you to perform Seri

Gura Config Lang 21 Nov 13, 2022
Front Matter parser for Rust.

fronma Front Matter parser for Rust. Usage Add this crate as a dependency: [dependencies] fronma = "~0.1" then use fronma::parser::parse to parse text

Ryo Nakamura 6 Nov 19, 2021
Owner
Huang Liuhaoran
TS/Rust lover; Senior frontend developer with expanded skills in graphic design, music composition and sound design
Huang Liuhaoran
GitHub
A CSS parser, transformer, and minifier written in Rust.

@parcel/css A CSS parser, transformer, and minifier written in Rust. Features Extremely fast – Parsing and minifying large files is completed in milli

Parcel 3.1k Jan 9, 2023
Yet Another Parser library for Rust. A lightweight, dependency free, parser combinator inspired set of utility methods to help with parsing strings and slices.

Yap: Yet another (rust) parsing library A lightweight, dependency free, parser combinator inspired set of utility methods to help with parsing input.

James Wilson 117 Dec 14, 2022
Website for Microformats Rust parser (using 'microformats-parser'/'mf2')

Website for Microformats Rust parser (using 'microformats-parser'/'mf2')

Microformats 5 Jul 19, 2022
A vcf parser that use memory mapping to get high performance.

biommap An efficient bioinformatics file parser based on memory mapping of file. WARNING: biommap work only on uncompressed seekable file biommap is t

Pierre Marijon 2 Dec 15, 2022
A typed parser generator embedded in Rust code for Parsing Expression Grammars

Oak Compiled on the nightly channel of Rust. Use rustup for managing compiler channels. You can download and set up the exact same version of the comp

Pierre Talbot 138 Nov 25, 2022
This crate provide parsing fontconfig file but not yet complete all features

This crate provide parsing fontconfig file but not yet complete all features

null 4 Dec 27, 2022
A native Rust port of Google's robots.txt parser and matcher C++ library.

robotstxt A native Rust port of Google's robots.txt parser and matcher C++ library. Native Rust port, no third-part crate dependency Zero unsafe code

Folyd 72 Dec 11, 2022
Rust parser combinator framework

nom, eating data byte by byte nom is a parser combinators library written in Rust. Its goal is to provide tools to build safe parsers without compromi

Geoffroy Couprie 7.6k Jan 7, 2023
Parsing Expression Grammar (PEG) parser generator for Rust

Parsing Expression Grammars in Rust Documentation | Release Notes rust-peg is a simple yet flexible parser generator that makes it easy to write robus

Kevin Mehall 1.2k Dec 30, 2022
A fast monadic-style parser combinator designed to work on stable Rust.

Chomp Chomp is a fast monadic-style parser combinator library designed to work on stable Rust. It was written as the culmination of the experiments de

Martin Wernstål 228 Oct 31, 2022