Home / Function/ process() — tailwindcss Function Reference

process() — tailwindcss Function Reference

Architecture documentation for the process() function in clojure.rs from the tailwindcss codebase.

Entity Profile

Dependency Diagram

graph TD
  5a027b49_30e5_8153_230e_0018cf161193["process()"]
  435a321a_a1e2_cb4f_7579_0ca15cb86434["advance()"]
  5a027b49_30e5_8153_230e_0018cf161193 -->|calls| 435a321a_a1e2_cb4f_7579_0ca15cb86434
  07207bb0_f195_4067_2024_eb12d4800851["advance_twice()"]
  5a027b49_30e5_8153_230e_0018cf161193 -->|calls| 07207bb0_f195_4067_2024_eb12d4800851
  14c3034a_c02e_1114_c440_db334170d05d["is_keyword_character()"]
  5a027b49_30e5_8153_230e_0018cf161193 -->|calls| 14c3034a_c02e_1114_c440_db334170d05d
  style 5a027b49_30e5_8153_230e_0018cf161193 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

crates/oxide/src/extractor/pre_processors/clojure.rs lines 26–198

    fn process(&self, content: &[u8]) -> Vec<u8> {
        let content = content
            .replace(":class", "      ")
            .replace(":className", "          ");
        let len = content.len();
        let mut result = content.to_vec();
        let mut cursor = cursor::Cursor::new(&content);

        while cursor.pos < len {
            match cursor.curr {
                // Consume strings as-is
                b'"' => {
                    result[cursor.pos] = b' ';
                    cursor.advance();

                    while cursor.pos < len {
                        match cursor.curr {
                            // Escaped character, skip ahead to the next character
                            b'\\' => cursor.advance_twice(),

                            // End of the string
                            b'"' => {
                                result[cursor.pos] = b' ';
                                break;
                            }

                            // Everything else is valid
                            _ => cursor.advance(),
                        };
                    }
                }

                // Discard line comments until the end of the line.
                // Comments start with `;;`
                b';' if matches!(cursor.next, b';') => {
                    while cursor.pos < len && cursor.curr != b'\n' {
                        result[cursor.pos] = b' ';
                        cursor.advance();
                    }
                }

                // Consume keyword until a terminating character is reached.
                b':' => {
                    result[cursor.pos] = b' ';
                    cursor.advance();

                    while cursor.pos < len {
                        match cursor.curr {
                            // A `.` surrounded by digits is a decimal number, so we don't want to replace it.
                            //
                            // E.g.:
                            // ```
                            // gap-1.5
                            //      ^
                            // ```
                            b'.' if cursor.prev.is_ascii_digit()
                                && cursor.next.is_ascii_digit() =>
                            {
                                // Keep the `.` as-is
                            }
                            // A `.` not surrounded by digits denotes the start of a new class name in a
                            // dot-delimited keyword.
                            //
                            // E.g.:
                            // ```
                            // flex.gap-1.5
                            //     ^
                            // ```
                            b'.' => {
                                result[cursor.pos] = b' ';
                            }
                            // End of keyword.
                            _ if !is_keyword_character(cursor.curr) => {
                                result[cursor.pos] = b' ';
                                break;
                            }

                            // Consume everything else.
                            _ => {}
                        };

                        cursor.advance();
                    }
                }

                // Handle quote with a list, e.g.: `'(…)`
                // and with a vector, e.g.: `'[…]`
                b'\'' if matches!(cursor.next, b'[' | b'(') => {
                    result[cursor.pos] = b' ';
                    cursor.advance();
                    result[cursor.pos] = b' ';
                    let end = match cursor.curr {
                        b'[' => b']',
                        b'(' => b')',
                        _ => unreachable!(),
                    };

                    // Consume until the closing `]`
                    while cursor.pos < len {
                        match cursor.curr {
                            x if x == end => {
                                result[cursor.pos] = b' ';
                                break;
                            }

                            // Consume strings as-is
                            b'"' => {
                                result[cursor.pos] = b' ';
                                cursor.advance();

                                while cursor.pos < len {
                                    match cursor.curr {
                                        // Escaped character, skip ahead to the next character
                                        b'\\' => cursor.advance_twice(),

                                        // End of the string
                                        b'"' => {
                                            result[cursor.pos] = b' ';
                                            break;
                                        }

                                        // Everything else is valid
                                        _ => cursor.advance(),
                                    };
                                }
                            }
                            _ => {}
                        };

                        cursor.advance();
                    }
                }

                // Handle quote with a keyword, e.g.: `'bg-white`
                b'\'' if !cursor.next.is_ascii_whitespace() => {
                    result[cursor.pos] = b' ';
                    cursor.advance();

                    while cursor.pos < len {
                        match cursor.curr {
                            // End of keyword.
                            _ if !is_keyword_character(cursor.curr) => {
                                result[cursor.pos] = b' ';
                                break;
                            }

                            // Consume everything else.
                            _ => {}
                        };

                        cursor.advance();
                    }
                }

                // Aggressively discard everything else, reducing false positives and preventing
                // characters surrounding keywords from producing false negatives.
                // E.g.:
                // ```
                // (when condition :bg-white)
                //                          ^
                // ```
                // A ')' is never a valid part of a keyword, but will nonetheless prevent 'bg-white'
                // from being extracted if not discarded.
                _ => {
                    result[cursor.pos] = b' ';
                }
            };

            cursor.advance();
        }

        result
    }

Domain

Subdomains

Frequently Asked Questions

What does process() do?
process() is a function in the tailwindcss codebase.
What does process() call?
process() calls 3 function(s): advance, advance_twice, is_keyword_character.

Analyze Your Own Codebase

Get architecture documentation, dependency graphs, and domain analysis for your codebase in minutes.

Try Supermodel Free