tiny.css.value

1/// Which shapes a grammar admits, plus the keywords it names. One generic2/// reader consumes this so a property table entry stays a single enum tag.3pub const Accept = struct {4    length: bool = false,5    percent: bool = false,6    number: bool = false,7    integer: bool = false,8    color: bool = false,9    string: bool = false,10    url: bool = false,11    raw: bool = false,12    keywords: []const Keyword = &.{},13};

1pub const Declaration = extern struct {2    property: u32,3    kind: u8,4    unit: u8,5    flags: u16,6    a: u32,7    b: u32,89    /// The value this declaration carries. Importance is a cascade input10    /// rather than part of the value, so it is dropped here.11    pub fn value(self: Declaration) Value {12        return .{13            .kind = self.kind,14            .unit = self.unit,15            .flags = self.flags & ~flag_important,16            .a = self.a,17            .b = self.b,18        };19    }2021    pub fn important(self: Declaration) bool {22        return self.flags & flag_important != 0;23    }24};

1/// The value grammar a property accepts. `value.parse` switches on it, so a2/// property table entry names a grammar rather than carrying a parser.3pub const Grammar = enum(u8) {4    length,5    length_percentage,6    length_percentage_auto,7    size,8    number,9    integer,10    opacity,11    color,12    string,13    url,14    display,15    position,16    overflow,17    visibility,18    box_sizing,19    flex_direction,20    flex_wrap,21    justify,22    @"align",23    align_self,24    text_align,25    text_transform,26    white_space,27    font_style,28    font_weight,29    font_family,30    line_height,31    border_style,32    text_decoration_line,33    cursor,34    list_style_type,35    vertical_align,36    content,37    z_index,38    gap,39    flex_basis,40    length_normal,41    direction,42    text_overflow,43    word_break,44    overflow_wrap,45    object_fit,46    pointer_events,47    user_select,48    list_style_position,49    background_repeat,50    background_size,51    background_box,52    background_attachment,53};

1/// Every keyword this engine understands, in one closed set so that a computed2/// keyword is an integer rather than a byte slice.3pub const Keyword = enum(u32) {4    invalid = 0,5    inherit,6    initial,7    unset,8    revert,9    auto,10    none,11    normal,12    block,13    @"inline",14    inline_block,15    flex,16    inline_flex,17    contents,18    static,19    relative,20    absolute,21    fixed,22    sticky,23    visible,24    hidden,25    scroll,26    clip,27    collapse,28    content_box,29    border_box,30    row,31    row_reverse,32    column,33    column_reverse,34    nowrap,35    wrap,36    wrap_reverse,37    flex_start,38    flex_end,39    center,40    space_between,41    space_around,42    space_evenly,43    start,44    end,45    stretch,46    baseline,47    left,48    right,49    justify,50    capitalize,51    uppercase,52    lowercase,53    pre,54    pre_wrap,55    pre_line,56    break_spaces,57    italic,58    oblique,59    bold,60    bolder,61    lighter,62    solid,63    dashed,64    dotted,65    double,66    groove,67    ridge,68    inset,69    outset,70    underline,71    overline,72    line_through,73    default,74    pointer,75    text,76    move,77    not_allowed,78    grab,79    grabbing,80    crosshair,81    wait,82    help,83    progress,84    disc,85    circle,86    square,87    decimal,88    lower_alpha,89    upper_alpha,90    lower_roman,91    upper_roman,92    top,93    middle,94    bottom,95    sub,96    super,97    text_top,98    text_bottom,99    min_content,100    max_content,101    fit_content,102    content,103    currentcolor,104    transparent,105    ltr,106    rtl,107    ellipsis,108    break_all,109    keep_all,110    break_word,111    anywhere,112    fill,113    contain,114    cover,115    scale_down,116    all,117    inside,118    outside,119    repeat,120    repeat_x,121    repeat_y,122    no_repeat,123    space,124    round,125    padding_box,126    local,127128    /// Resolves a keyword by its CSS spelling, where an underscore in the tag129    /// stands for a hyphen.130    pub fn parse(word: []const u8) ?Keyword {131        if (word.len == 0 or word.len > max_keyword_bytes) return null;132        var buffer: [max_keyword_bytes]u8 = undefined;133        for (word, 0..) |byte, index| {134            buffer[index] = if (byte == '-') '_' else std.ascii.toLower(byte);135        }136        return std.meta.stringToEnum(Keyword, buffer[0..word.len]);137    }138139    /// The CSS spelling of this keyword, with hyphens restored.140    pub fn spelling(self: Keyword) []const u8 {141        @setEvalBranchQuota(64_000);142        return switch (self) {143            inline else => |tag| comptime spell(@tagName(tag)),144        };145    }146};

1/// How the `a` and `b` words of a value are read.2///3/// `asset` and `pair` are part of the published record layout and are produced4/// by the tree publisher rather than by a stylesheet.5pub const Kind = enum(u8) {6    invalid = 0,7    keyword = 1,8    length = 2,9    percent = 3,10    number = 4,11    color = 5,12    string = 6,13    asset = 7,14    pair = 8,15};

1/// The unit a `length` carries. A percentage is a `Kind`, not a unit.2pub const Unit = enum(u8) {3    none = 0,4    px = 1,5    em = 2,6    rem = 3,7    ch = 4,8    lh = 5,9    ex = 6,10    vw = 7,11    vh = 8,12    vmin = 9,13    vmax = 10,14    fr = 11,15    deg = 12,16    s = 13,17    ms = 14,1819    /// Resolves a dimension unit by name, folded to ASCII lower case.20    pub fn parse(spelling: []const u8) ?Unit {21        const info = @typeInfo(Unit).@"enum";22        inline for (info.field_names, info.field_values) |field_name, field_value| {23            if (field_value != 0 and std.ascii.eqlIgnoreCase(spelling, field_name)) {24                return @fromBackingInt(@intCast(field_value));25            }26        }27        return null;28    }29};

1/// One computed value. Twelve bytes, laid out as the published declaration2/// record minus its property word.3pub const Value = extern struct {4    kind: u8 = @backingInt(Kind.invalid),5    unit: u8 = @backingInt(Unit.none),6    flags: u16 = 0,7    a: u32 = 0,8    b: u32 = 0,910    pub fn keyword(word: Keyword) Value {11        return .{ .kind = @backingInt(Kind.keyword), .a = @backingInt(word) };12    }1314    pub fn length(amount: f32, unit: Unit) Value {15        return .{16            .kind = @backingInt(Kind.length),17            .unit = @backingInt(unit),18            .a = @bitCast(amount),19        };20    }2122    pub fn percent(amount: f32) Value {23        return .{ .kind = @backingInt(Kind.percent), .a = @bitCast(amount) };24    }2526    pub fn number(amount: f32) Value {27        return .{ .kind = @backingInt(Kind.number), .a = @bitCast(amount) };28    }2930    pub fn color(packed_rgba: u32) Value {31        return .{ .kind = @backingInt(Kind.color), .a = packed_rgba };32    }3334    pub fn string(offset: u32, length_bytes: u32) Value {35        return .{ .kind = @backingInt(Kind.string), .a = offset, .b = length_bytes };36    }3738    pub fn valueKind(self: Value) Kind {39        return @fromBackingInt(@intCast(self.kind));40    }4142    pub fn valueUnit(self: Value) Unit {43        return @fromBackingInt(@intCast(self.unit));44    }4546    /// The keyword behind a keyword value, or `invalid` for any other kind.47    pub fn asKeyword(self: Value) Keyword {48        if (self.valueKind() != .keyword) return .invalid;49        return @fromBackingInt(@intCast(self.a));50    }5152    /// The scalar behind a length, percentage, or number.53    pub fn asNumber(self: Value) f32 {54        std.debug.assert(numeric(self.valueKind()));55        return @bitCast(self.a);56    }5758    /// The source span behind a string value.59    pub fn asString(self: Value, source: []const u8) []const u8 {60        std.debug.assert(self.valueKind() == .string);61        return source[self.a..][0..self.b];62    }6364    pub fn present(self: Value) bool {65        return self.valueKind() != .invalid;66    }6768    /// Binds this value to a property, producing the published record.69    pub fn declare(self: Value, property: u32, important: bool) Declaration {70        return .{71            .property = property,72            .kind = self.kind,73            .unit = self.unit,74            .flags = self.flags | (if (important) flag_important else 0),75            .a = self.a,76            .b = self.b,77        };78    }79};

1/// The admitted shapes of one grammar.2pub fn accepted(grammar: Grammar) Accept {3    return switch (grammar) {4        .length => .{ .length = true },5        .length_percentage => .{ .length = true, .percent = true },6        .length_percentage_auto => .{ .length = true, .percent = true, .keywords = &.{.auto} },7        .size => .{ .length = true, .percent = true, .keywords = &.{8            .auto,        .none,        .min_content,9            .max_content, .fit_content,10        } },11        .number => .{ .number = true },12        .integer => .{ .integer = true },13        .opacity => .{ .number = true, .percent = true },14        .color => .{ .color = true },15        .string => .{ .string = true },16        .url => .{ .url = true, .keywords = &.{.none} },17        .display => .{ .keywords = &.{18            .block,       .@"inline", .inline_block, .flex,19            .inline_flex, .none,      .contents,20        } },21        .position => .{ .keywords = &.{ .static, .relative, .absolute, .fixed, .sticky } },22        .overflow => .{ .keywords = &.{ .visible, .hidden, .scroll, .auto, .clip } },23        .visibility => .{ .keywords = &.{ .visible, .hidden, .collapse } },24        .box_sizing => .{ .keywords = &.{ .content_box, .border_box } },25        .flex_direction => .{ .keywords = &.{ .row, .row_reverse, .column, .column_reverse } },26        .flex_wrap => .{ .keywords = &.{ .nowrap, .wrap, .wrap_reverse } },27        .justify => .{ .keywords = &.{28            .flex_start,   .flex_end, .center, .space_between, .space_around,29            .space_evenly, .start,    .end,    .stretch,       .normal,30            .left,         .right,31        } },32        .@"align" => .{ .keywords = &.{33            .flex_start, .flex_end, .center, .baseline,34            .stretch,    .start,    .end,    .normal,35        } },36        .align_self => .{ .keywords = &.{37            .auto,     .flex_start, .flex_end, .center,38            .baseline, .stretch,    .start,    .end,39        } },40        .text_align => .{ .keywords = &.{ .left, .right, .center, .justify, .start, .end } },41        .text_transform => .{ .keywords = &.{ .none, .capitalize, .uppercase, .lowercase } },42        .white_space => .{ .keywords = &.{43            .normal, .nowrap, .pre, .pre_wrap, .pre_line, .break_spaces,44        } },45        .font_style => .{ .keywords = &.{ .normal, .italic, .oblique } },46        .font_weight => .{ .number = true, .keywords = &.{ .normal, .bold, .bolder, .lighter } },47        .font_family => .{ .raw = true },48        .line_height => .{49            .number = true,50            .length = true,51            .percent = true,52            .keywords = &.{.normal},53        },54        .border_style => .{ .keywords = &.{55            .none,   .hidden, .solid, .dashed, .dotted,56            .double, .groove, .ridge, .inset,  .outset,57        } },58        .text_decoration_line => .{ .keywords = &.{59            .none, .underline, .overline, .line_through,60        } },61        .cursor => .{ .keywords = &.{62            .auto, .default,  .pointer,   .text, .move, .not_allowed,63            .grab, .grabbing, .crosshair, .wait, .help, .progress,64        } },65        .list_style_type => .{ .keywords = &.{66            .none,        .disc,        .circle,      .square,      .decimal,67            .lower_alpha, .upper_alpha, .lower_roman, .upper_roman,68        } },69        .vertical_align => .{ .length = true, .percent = true, .keywords = &.{70            .baseline, .top, .middle, .bottom, .sub, .super, .text_top, .text_bottom,71        } },72        .content => .{ .string = true, .keywords = &.{ .none, .normal } },73        .z_index => .{ .integer = true, .keywords = &.{.auto} },74        .gap => .{ .length = true, .percent = true, .keywords = &.{.normal} },75        .flex_basis => .{ .length = true, .percent = true, .keywords = &.{ .auto, .content } },76        .length_normal => .{ .length = true, .keywords = &.{.normal} },77        .direction => .{ .keywords = &.{ .ltr, .rtl } },78        .text_overflow => .{ .keywords = &.{ .clip, .ellipsis } },79        .word_break => .{ .keywords = &.{ .normal, .break_all, .keep_all } },80        .overflow_wrap => .{ .keywords = &.{ .normal, .break_word, .anywhere } },81        .object_fit => .{ .keywords = &.{ .fill, .contain, .cover, .none, .scale_down } },82        .pointer_events => .{ .keywords = &.{ .auto, .none } },83        .user_select => .{ .keywords = &.{ .auto, .none, .text, .all } },84        .list_style_position => .{ .keywords = &.{ .inside, .outside } },85        .background_repeat => .{ .keywords = &.{86            .repeat, .repeat_x, .repeat_y, .no_repeat, .space, .round,87        } },88        .background_size => .{ .length = true, .percent = true, .keywords = &.{89            .auto, .cover, .contain,90        } },91        .background_box => .{ .keywords = &.{ .border_box, .padding_box, .content_box } },92        .background_attachment => .{ .keywords = &.{ .scroll, .fixed, .local } },93    };94}

1/// Whether `source[start..end]` carries a `var()` reference, which defers the2/// value to computed value time.3pub fn hasVariable(source: []const u8, start: u32, end: u32) bool {4    std.debug.assert(start <= end);5    std.debug.assert(end <= source.len);6    var tokenizer = token.Tokenizer{ .source = source[0..end], .index = start };7    var guard: usize = 0;8    while (guard <= source.len + 1) : (guard += 1) {9        const next = tokenizer.next();10        if (next.kind == .eof) return false;11        if (next.kind != .function) continue;12        if (std.ascii.eqlIgnoreCase(next.value(source), "var")) return true;13    }14    return false;15}

1/// Reads `source[start..end]` under `grammar`. String offsets are absolute, so2/// a computed string value indexes the same source the sheet borrows.3/// Returns an invalid value when the text is not a complete match.4pub fn parse(grammar: Grammar, source: []const u8, start: u32, end: u32) Value {5    std.debug.assert(start <= end);6    std.debug.assert(end <= source.len);7    const rules = accepted(grammar);8    var tokenizer = token.Tokenizer{ .source = source[0..end], .index = start };9    const first = nextMeaningful(&tokenizer);10    if (first.kind == .eof) return .{};11    if (first.kind == .ident) {12        if (Keyword.parse(first.value(source))) |word| {13            if (contains(&wide, word)) return sealed(&tokenizer, Value.keyword(word));14        }15    }16    if (rules.raw) {17        const body = std.mem.trim(u8, source[start..end], " \t\r\n\x0C");18        if (body.len == 0) return .{};19        const offset = @intFromPtr(body.ptr) - @intFromPtr(source.ptr);20        return Value.string(@intCast(offset), @intCast(body.len));21    }22    const value = single(rules, &tokenizer, first, source);23    if (!value.present()) return .{};24    return sealed(&tokenizer, value);25}

1/// The four keywords every property accepts.2pub const wide = [_]Keyword{ .inherit, .initial, .unset, .revert };

1/// Bit zero of the `flags` word marks an important declaration.2pub const flag_important: u16 = 1;

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

1//! Typed CSS values and the sixteen byte declaration record they lower into.2//!3//! A stylesheet parses strings once at load. Everything downstream reads a4//! `Declaration`: a property word, a kind, a unit, a flag word, and two scalar5//! words. A directly authored inline style writes the same record without6//! parsing anything, so one representation serves both producers.7//!8//! Lengths, percentages, numbers, colours, and keywords fit the two scalar9//! words outright. A string keeps a byte offset and a length into the source10//! the stylesheet borrows, so no value owns heap memory.11//!12//! `parse` is driven by a `Grammar` tag rather than by a property identifier,13//! which keeps this namespace free of the property table and makes the value14//! reader testable one grammar at a time.1516const parser = @import("parse.zig");17const scalar = @import("scalar.zig");1819pub const color = @import("color.zig");2021pub const Accept = parser.Accept;22pub const Declaration = scalar.Declaration;23pub const Grammar = scalar.Grammar;24pub const Keyword = scalar.Keyword;25pub const Kind = scalar.Kind;26pub const Unit = scalar.Unit;27pub const Value = scalar.Value;28pub const accepted = parser.accepted;29pub const flag_important = scalar.flag_important;30pub const hasVariable = parser.hasVariable;31pub const parse = parser.parse;32pub const wide = parser.wide;