What’s New

csstree v3.0.0

v3.0.0

3.0.0

Added
  • Support for the @container at-rule
  • Support for the @starting-style at-rule
  • Support for the @scope at-rule
  • Support for the @position-try at-rule
  • Support for the @layer at-rule
  • Support for layer, layer() and supports() in the @media at-rule
  • Layer and LayerList node types
  • TokenStream#lookupTypeNonSC() method
  • <dashed-ident> to generic types
  • Feature, FeatureRange, FeatureFunction, Condition, and GeneralEnclosure node types for query-related at-rules
  • Support for functions in features and features in range context
  • SupportsDeclaration node type to encapsulate a declaration in a @supports query
  • Support for the selector() feature in @supports at-rule via FeatureFunction node
Changed
  • Aligned <'font'> to CSS Fonts 4
  • Aligned <color> to CSS Color 5
  • Block to not include { and }
  • Atrule and Rule to include { and } for a block
  • Ratio parsing to use nodes instead of strings for left and right parts, allow any number for both parts, support functions in both parts, and permit omitting the right part
  • MediaFeature node type transitioned to Feature node type with kind: "media" in @media at-rule
  • MediaQuery node structure to include modifier, mediaType, and condition properties
  • parseWithFallback() to rollback tokenIndex before calling a fallback
Fixed
  • Initialization when Object.prototype is extended or polluted
  • fork() method to consider the generic option when creating a Lexer instance
  • Crash on parse error when custom line or offset is specified via options
  • speak syntax patch
  • :lang() to accept a list of <ident> or <string> per spec
  • Lexer matching for syntaxes referred to as <'property'> when the syntax has a top-level #-multiplier
  • Parsing of syntax definition to allow whitespaces in range multiplier
  • Added support for the @container at-rule
  • Added support for the @starting-style at-rule
  • Added support for the @scope at-rule
  • Added support for the @position-try at-rule
  • Added support for the @layer at-rule
  • Added support for layer, layer() and supports() in the @media at-rule (according to the @import rule in Cascading and Inheritance 5)
  • Added Layer and LayerList node types
  • Added TokenStream#lookupTypeNonSC() method
  • Added <dashed-ident> to generic types
  • Bumped mdn/data to 2.10.0
  • Aligned <'font'> to CSS Fonts 4
  • Aligned <color> to CSS Color 5
  • Fixed initialization when Object.prototype is extended or polluted (#262)
  • Fixed fork() method to consider the generic option when creating a Lexer instance (#266)
  • Fixed crash on parse error when custom line or offset is specified via options (#251)
  • Fixed speak syntax patch (#241)
  • Fixed :lang() to accept a list of <ident> or <string> per spec (#265)
  • Fixed lexer matching for syntaxes referred to as <'property'>, when the syntax has a top-level #-multiplier (#102)
  • Relaxed parsing of syntax definition to allow whitespaces in range multiplier (#270)
  • Changed parseWithFallback() to rollback tokenIndex before calling a fallback
  • Changed Block to not include { and }
  • Changed Atrule and Rule to include { and } for a block
  • Changed Ratio parsing:
    • Left and right parts contain nodes instead of strings
    • Both left and right parts of a ratio can now be any number; validation of number range is no longer within the parser's scope.
    • Both parts can now be functions. Although not explicitly mentioned in the specification, mathematical functions can replace numbers, addressing potential use cases (#162).
    • As per the CSS Values and Units Level 4 specification, the right part of Ratio can be omitted. While this can't be a parser output (which would produce a Number node), it's feasible during Ratio node construction or transformation.
  • Changes to query-related at-rules:
    • Added new node types:
      • Feature: represents features like (feature) and (feature: value), fundamental for both @media and @container at-rules
      • FeatureRange: represents features in a range context
      • FeatureFunction: represents functional features such as @supports's selector() or @container's style()
      • Condition: used across all query-like at-rules, encapsulating queries with features and the not, and, and or operators
      • GeneralEnclosure: represents the <general-enclosed> production, which caters to unparsed parentheses or functional expressions

      Note: All new nodes include a kind property to define the at-rule type. Supported kinds are media, supports, and container

    • Added support for functions for features and features in a range context, e.g. (width: calc(100cm / 6))
    • Added a condition value for the parser's context option to parse queries. Use the kind option to specify the condition type, e.g., parse('...', { context: 'condition', kind: 'media' })
    • Introduced a features section in the syntax configuration for defining functional features of at-rules. Expand definitions using the fork() method. The current definition is as follows: 
      features: {
    supports: { selector() { /* ... */ } },
    container: { style() { /* ... */ } }
}
    • Changes for @media at-rule:
      • Enhanced prelude parsing for complex queries. Parentheses with errors will be parsed as GeneralEnclosed
      • Added support for features in a range context, e.g. (width > 100px) or (100px < height < 400px)
      • Transitioned from MediaFeature node type to the Feature node type with kind: "media"
      • Changed MediaQuery node structure into the following form: 
        type MediaQuery = {
    type: "MediaQuery";
    modifier: string | null; // e.g. "not", "only", etc.
    mediaType: string | null; // e.g. "all", "screen", etc.
    condition: Condition | null;
}
    • Changes for @supports at-rule:
      • Enhanced prelude parsing for complex queries. Parentheses with errors will be parsed as GeneralEnclosed
      • Added support for features in a range context, e.g. (width > 100px) or (100px < height < 400px)
      • Added SupportsDeclaration node type to encapsulate a declaration in a query, replacing Parentheses
      • Parsing now employs Condition or SupportsDeclaration nodes of kind supports instead of Parentheses
      • Added support for the selector() feature via the FeatureFunction node (configured in features.supports.selector)
View original