tiny.css.selector

1/// The strongest key of a selector's rightmost compound. The rule bucket index2/// groups selectors by this key so a node visits few candidates.3pub const BucketKey = union(enum(u8)) {4    universal,5    id: u32,6    class: u32,7    role: u16,8    kind: u16,9};

1/// Builds compiled selectors into placement arrays, or counts them when the2/// arrays are absent. One builder serves both passes so the inspection and3/// emission walks cannot drift.4pub const Builder = struct {5    source: []const u8,6    atoms: ?*atom.Table = null,7    classes: ?[]u32 = null,8    compounds: ?[]Compound = null,9    combinators: ?[]Combinator = null,10    nths: ?[]nth.Nth = null,11    selectors: ?[]Selector = null,12    diagnostics: ?[][]const u8 = null,1314    class_used: u32 = 0,15    compound_used: u32 = 0,16    combinator_used: u32 = 0,17    nth_used: u32 = 0,18    selector_used: u32 = 0,19    atom_used: u32 = 0,20    atom_bytes: u32 = 0,21    dependency_used: u32 = 0,22    diagnostic_used: u32 = 0,2324    /// Interns one identifier, folding it when the position is case25    /// insensitive. Returns `atom.none` when the identifier cannot be held.26    pub fn intern(self: *Builder, text: []const u8, folded: bool) error{CapacityOverflow}!u32 {27        if (text.len == 0 or text.len > atom.max_text_bytes) return atom.none;28        var buffer: [atom.max_text_bytes]u8 = undefined;29        var body = text;30        var copy = false;31        if (token.hasEscape(body)) {32            body = token.unescape(body, &buffer) orelse return atom.none;33            copy = true;34        }35        if (folded and needsFold(body)) {36            if (!copy) @memcpy(buffer[0..body.len], body);37            for (buffer[0..body.len]) |*byte| byte.* = std.ascii.toLower(byte.*);38            body = buffer[0..body.len];39            copy = true;40        }41        if (body.len == 0) return atom.none;42        if (self.atoms) |table| return table.intern(body, copy);43        self.atom_used = try grow(self.atom_used, 1);44        if (copy) self.atom_bytes = try grow(self.atom_bytes, @intCast(body.len));45        return self.atom_used;46    }4748    fn pushClass(self: *Builder, id: u32) error{CapacityOverflow}!void {49        if (self.classes) |slice| {50            std.debug.assert(self.class_used < slice.len);51            slice[self.class_used] = id;52        }53        self.class_used = try grow(self.class_used, 1);54    }5556    fn pushCompound(self: *Builder, compound: Compound) error{CapacityOverflow}!void {57        if (self.compounds) |slice| {58            std.debug.assert(self.compound_used < slice.len);59            slice[self.compound_used] = compound;60        }61        self.compound_used = try grow(self.compound_used, 1);62    }6364    fn pushCombinator(self: *Builder, joint: Combinator) error{CapacityOverflow}!void {65        if (self.combinators) |slice| {66            std.debug.assert(self.combinator_used < slice.len);67            slice[self.combinator_used] = joint;68        }69        self.combinator_used = try grow(self.combinator_used, 1);70    }7172    fn pushNth(self: *Builder, out: *Compound, record: nth.Nth) error{CapacityOverflow}!void {73        const id = try grow(self.nth_used, 1);74        if (self.nths) |slice| {75            std.debug.assert(self.nth_used < slice.len);76            slice[self.nth_used] = record;77        }78        self.nth_used = id;79        if (out.nth == 0) {80            out.nth = id;81            return;82        }83        const slice = self.nths orelse return;84        var walk = out.nth;85        var guard: usize = 0;86        while (slice[walk - 1].next != 0 and guard <= slice.len) : (guard += 1) {87            walk = slice[walk - 1].next;88        }89        slice[walk - 1].next = id;90    }9192    /// Records one diagnostic against the shared diagnostic cursor.93    pub fn note(self: *Builder, text: []const u8) error{CapacityOverflow}!void {94        if (self.diagnostics) |slice| {95            std.debug.assert(self.diagnostic_used < slice.len);96            slice[self.diagnostic_used] = text;97        }98        self.diagnostic_used = try grow(self.diagnostic_used, 1);99    }100101    fn flagLast(self: *Builder) void {102        const slice = self.compounds orelse return;103        if (self.compound_used == 0) return;104        slice[self.compound_used - 1].flags |= unmatchable;105    }106};

1/// How two compounds are joined. The list runs left to right, so2/// `combinators[i]` joins `compounds[i]` to `compounds[i + 1]`.3pub const Combinator = enum(u8) {4    descendant,5    child,6    next_sibling,7    subsequent_sibling,8};

1/// One compound selector. Every identifier is an interned atom, so matching a2/// compound is a run of integer compares.3pub const Compound = extern struct {4    kind: u16 = 0,5    role: u16 = 0,6    id: u32 = 0,7    class_first: u32 = 0,8    class_count: u16 = 0,9    flags: u16 = 0,10    pseudo: u32 = 0,11    nth: u32 = 0,12};

1/// The interaction and node state pseudo-classes, one bit each. An element2/// interface reports them as one word, so `:hover` and `[state~=selected]` are3/// the same test on the same bit.4pub const PseudoClass = enum(u5) {5    hover = 0,6    focus = 1,7    focus_visible = 2,8    focus_within = 3,9    active = 4,10    target = 5,11    root = 6,12    empty = 7,13    enabled = 8,14    disabled = 9,15    checked = 10,16    indeterminate = 11,17    selected = 12,18    expanded = 13,19    pressed = 14,20    busy = 15,21    invalid = 16,22    required = 17,23    current = 18,24    mixed = 19,25    link = 20,26    visited = 21,27    read_only = 22,28    read_write = 23,29    placeholder_shown = 24,30    optional = 25,31    default = 26,32    open = 27,33    modal = 28,34    defined = 29,35};

1/// The span of selectors one selector list contributed.2pub const Range = struct {3    first: u32,4    count: u32,5};

1/// The bit `class` occupies in an element's pseudo-class word.2pub fn bit(class: PseudoClass) u32 {3    return @as(u32, 1) << @backingInt(class);4}

1/// Parses a comma separated selector list over `source[start..end]` and2/// returns the span of selectors it produced.3pub fn parseList(builder: *Builder, start: u32, end: u32) error{CapacityOverflow}!Range {4    std.debug.assert(start <= end);5    std.debug.assert(end <= builder.source.len);6    const first = builder.selector_used;7    var cursor = start;8    var guard: usize = 0;9    while (cursor <= end and guard <= builder.source.len + 1) : (guard += 1) {10        const comma = topLevelComma(builder.source, cursor, end) orelse end;11        try parseSelector(builder, cursor, comma);12        if (comma >= end) break;13        cursor = comma + 1;14    }15    return .{ .first = first, .count = builder.selector_used - first };16}

1/// Publishes one selector that never matches an element. An at-rule2/// descriptor block keeps its prelude text this way without joining matching.3pub fn parseOpaque(builder: *Builder, start: u32, end: u32) error{CapacityOverflow}!Range {4    std.debug.assert(start <= end);5    std.debug.assert(end <= builder.source.len);6    const first = builder.selector_used;7    const compound_first = builder.compound_used;8    const combinator_first = builder.combinator_used;9    try builder.pushCompound(.{ .flags = unmatchable });10    try publish(builder, .{11        .compound_first = compound_first,12        .combinator_first = combinator_first,13        .count = 1,14        .start = start,15        .end = end,16        .specificity = .{},17    });18    return .{ .first = first, .count = builder.selector_used - first };19}

1/// Resolves a pseudo-class written with a colon, ASCII case insensitively.2pub fn pseudoByName(name: []const u8) ?PseudoClass {3    return byName(name);4}

1/// Resolves one of the ten published node states, written `[state~=name]`.2pub fn stateByName(name: []const u8) ?PseudoClass {3    const found = byName(name) orelse return null;4    for (states) |candidate| {5        if (candidate == found) return found;6    }7    return null;8}

1/// The node states the published node record carries in its `state` word.2pub const states = [_]PseudoClass{3    .selected, .disabled, .expanded, .checked,  .mixed,4    .pressed,  .busy,     .invalid,  .required, .current,5};

1/// Set on a compound whose grammar named something the node model cannot2/// carry. Such a compound never matches, which is what CSS requires of a3/// selector over an attribute no element has.4pub const unmatchable: u16 = 1;

1pub const selector = @import("selector/root.zig");

1//! The selector grammar: compounds, combinators, specificity, and bucket keys.2//!3//! A compound holds interned atoms rather than byte slices, so matching is a4//! run of integer compares and a rule bucket is an integer key. Interaction5//! pseudo-classes and the published node states share one bit word, which is6//! why `:disabled` and `[state~=disabled]` are the same test.7//!8//! Attribute selectors cover the four keys the node model carries: `id`,9//! `class`, `role`, and `state`. A selector over any other attribute parses,10//! reports a diagnostic, and is marked unmatchable, which is the CSS result for11//! an attribute no element in the model can hold.12//!13//! `Builder` runs both passes. With its placement arrays absent it counts, with14//! them present it fills, so the inspection and emission walks cannot drift.1516const grammar = @import("grammar.zig");17const nth_expression = @import("nth.zig");1819pub const nth = nth_expression;2021pub const BucketKey = grammar.BucketKey;22pub const Builder = grammar.Builder;23pub const Combinator = grammar.Combinator;24pub const Compound = grammar.Compound;25pub const PseudoClass = grammar.PseudoClass;26pub const Range = grammar.Range;27pub const Selector = grammar.Selector;28pub const Specificity = grammar.Specificity;29pub const bit = grammar.bit;30pub const parseList = grammar.parseList;31pub const parseOpaque = grammar.parseOpaque;32pub const pseudoByName = grammar.pseudoByName;33pub const stateByName = grammar.stateByName;34pub const states = grammar.states;35pub const unmatchable = grammar.unmatchable;