ether-code 0.1.5 → 0.1.7

package/parsers/ast-css.js

@@ -1,545 +0,0 @@
-class ASTNode {
-    constructor(type, loc = null) {
-        this.type = type
-        this.loc = loc
-    }
-}
-
-class StyleSheet extends ASTNode {
-    constructor(rules = [], loc = null) {
-        super('StyleSheet', loc)
-        this.rules = rules
-    }
-}
-
-class Rule extends ASTNode {
-    constructor(selectors, declarations, loc = null) {
-        super('Rule', loc)
-        this.selectors = selectors
-        this.declarations = declarations
-    }
-}
-
-class Selector extends ASTNode {
-    constructor(value, specificity = null, loc = null) {
-        super('Selector', loc)
-        this.value = value
-        this.specificity = specificity
-    }
-}
-
-class SelectorList extends ASTNode {
-    constructor(selectors = [], loc = null) {
-        super('SelectorList', loc)
-        this.selectors = selectors
-    }
-}
-
-class SimpleSelector extends ASTNode {
-    constructor(selectorType, value, loc = null) {
-        super('SimpleSelector', loc)
-        this.selectorType = selectorType
-        this.value = value
-    }
-}
-
-class CompoundSelector extends ASTNode {
-    constructor(selectors = [], loc = null) {
-        super('CompoundSelector', loc)
-        this.selectors = selectors
-    }
-}
-
-class ComplexSelector extends ASTNode {
-    constructor(left, combinator, right, loc = null) {
-        super('ComplexSelector', loc)
-        this.left = left
-        this.combinator = combinator
-        this.right = right
-    }
-}
-
-class PseudoClassSelector extends ASTNode {
-    constructor(name, argument = null, loc = null) {
-        super('PseudoClassSelector', loc)
-        this.name = name
-        this.argument = argument
-    }
-}
-
-class PseudoElementSelector extends ASTNode {
-    constructor(name, loc = null) {
-        super('PseudoElementSelector', loc)
-        this.name = name
-    }
-}
-
-class AttributeSelector extends ASTNode {
-    constructor(attribute, operator = null, value = null, flags = null, loc = null) {
-        super('AttributeSelector', loc)
-        this.attribute = attribute
-        this.operator = operator
-        this.value = value
-        this.flags = flags
-    }
-}
-
-class Declaration extends ASTNode {
-    constructor(property, value, important = false, loc = null) {
-        super('Declaration', loc)
-        this.property = property
-        this.value = value
-        this.important = important
-    }
-}
-
-class Property extends ASTNode {
-    constructor(name, cssName, loc = null) {
-        super('Property', loc)
-        this.name = name
-        this.cssName = cssName
-    }
-}
-
-class Value extends ASTNode {
-    constructor(value, cssValue = null, loc = null) {
-        super('Value', loc)
-        this.value = value
-        this.cssValue = cssValue
-    }
-}
-
-class ValueList extends ASTNode {
-    constructor(values = [], separator = ' ', loc = null) {
-        super('ValueList', loc)
-        this.values = values
-        this.separator = separator
-    }
-}
-
-class NumberValue extends ASTNode {
-    constructor(value, unit = null, loc = null) {
-        super('NumberValue', loc)
-        this.value = value
-        this.unit = unit
-    }
-}
-
-class PercentageValue extends ASTNode {
-    constructor(value, loc = null) {
-        super('PercentageValue', loc)
-        this.value = value
-    }
-}
-
-class ColorValue extends ASTNode {
-    constructor(colorType, value, cssValue = null, loc = null) {
-        super('ColorValue', loc)
-        this.colorType = colorType
-        this.value = value
-        this.cssValue = cssValue
-    }
-}
-
-class FunctionCall extends ASTNode {
-    constructor(name, cssName, args = [], loc = null) {
-        super('FunctionCall', loc)
-        this.name = name
-        this.cssName = cssName
-        this.args = args
-    }
-}
-
-class Identifier extends ASTNode {
-    constructor(name, cssName = null, loc = null) {
-        super('Identifier', loc)
-        this.name = name
-        this.cssName = cssName
-    }
-}
-
-class StringValue extends ASTNode {
-    constructor(value, quote = '"', loc = null) {
-        super('StringValue', loc)
-        this.value = value
-        this.quote = quote
-    }
-}
-
-class UrlValue extends ASTNode {
-    constructor(url, loc = null) {
-        super('UrlValue', loc)
-        this.url = url
-    }
-}
-
-class Variable extends ASTNode {
-    constructor(name, loc = null) {
-        super('Variable', loc)
-        this.name = name
-    }
-}
-
-class CustomProperty extends ASTNode {
-    constructor(name, value, loc = null) {
-        super('CustomProperty', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class MediaQuery extends ASTNode {
-    constructor(mediaType, conditions, rules, loc = null) {
-        super('MediaQuery', loc)
-        this.mediaType = mediaType
-        this.conditions = conditions
-        this.rules = rules
-    }
-}
-
-class MediaCondition extends ASTNode {
-    constructor(feature, value, operator = null, loc = null) {
-        super('MediaCondition', loc)
-        this.feature = feature
-        this.value = value
-        this.operator = operator
-    }
-}
-
-class ContainerQuery extends ASTNode {
-    constructor(name, conditions, rules, loc = null) {
-        super('ContainerQuery', loc)
-        this.name = name
-        this.conditions = conditions
-        this.rules = rules
-    }
-}
-
-class SupportsRule extends ASTNode {
-    constructor(condition, rules, loc = null) {
-        super('SupportsRule', loc)
-        this.condition = condition
-        this.rules = rules
-    }
-}
-
-class LayerRule extends ASTNode {
-    constructor(name, rules = null, loc = null) {
-        super('LayerRule', loc)
-        this.name = name
-        this.rules = rules
-    }
-}
-
-class KeyframesRule extends ASTNode {
-    constructor(name, keyframes = [], loc = null) {
-        super('KeyframesRule', loc)
-        this.name = name
-        this.keyframes = keyframes
-    }
-}
-
-class Keyframe extends ASTNode {
-    constructor(selector, declarations, loc = null) {
-        super('Keyframe', loc)
-        this.selector = selector
-        this.declarations = declarations
-    }
-}
-
-class FontFaceRule extends ASTNode {
-    constructor(declarations, loc = null) {
-        super('FontFaceRule', loc)
-        this.declarations = declarations
-    }
-}
-
-class ImportRule extends ASTNode {
-    constructor(url, mediaQueries = null, layer = null, supports = null, loc = null) {
-        super('ImportRule', loc)
-        this.url = url
-        this.mediaQueries = mediaQueries
-        this.layer = layer
-        this.supports = supports
-    }
-}
-
-class PageRule extends ASTNode {
-    constructor(selector, declarations, loc = null) {
-        super('PageRule', loc)
-        this.selector = selector
-        this.declarations = declarations
-    }
-}
-
-class PropertyRule extends ASTNode {
-    constructor(name, syntax, inherits, initialValue, loc = null) {
-        super('PropertyRule', loc)
-        this.name = name
-        this.syntax = syntax
-        this.inherits = inherits
-        this.initialValue = initialValue
-    }
-}
-
-class CounterStyleRule extends ASTNode {
-    constructor(name, declarations, loc = null) {
-        super('CounterStyleRule', loc)
-        this.name = name
-        this.declarations = declarations
-    }
-}
-
-class ScopeRule extends ASTNode {
-    constructor(start, end, rules, loc = null) {
-        super('ScopeRule', loc)
-        this.start = start
-        this.end = end
-        this.rules = rules
-    }
-}
-
-class StartingStyleRule extends ASTNode {
-    constructor(rules, loc = null) {
-        super('StartingStyleRule', loc)
-        this.rules = rules
-    }
-}
-
-class NestingRule extends ASTNode {
-    constructor(selector, declarations, nestedRules = [], loc = null) {
-        super('NestingRule', loc)
-        this.selector = selector
-        this.declarations = declarations
-        this.nestedRules = nestedRules
-    }
-}
-
-class GradientValue extends ASTNode {
-    constructor(gradientType, direction, stops, loc = null) {
-        super('GradientValue', loc)
-        this.gradientType = gradientType
-        this.direction = direction
-        this.stops = stops
-    }
-}
-
-class ColorStop extends ASTNode {
-    constructor(color, position = null, loc = null) {
-        super('ColorStop', loc)
-        this.color = color
-        this.position = position
-    }
-}
-
-class TransformValue extends ASTNode {
-    constructor(functions = [], loc = null) {
-        super('TransformValue', loc)
-        this.functions = functions
-    }
-}
-
-class FilterValue extends ASTNode {
-    constructor(functions = [], loc = null) {
-        super('FilterValue', loc)
-        this.functions = functions
-    }
-}
-
-class TimingFunction extends ASTNode {
-    constructor(name, values = null, loc = null) {
-        super('TimingFunction', loc)
-        this.name = name
-        this.values = values
-    }
-}
-
-class CalcExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('CalcExpression', loc)
-        this.expression = expression
-    }
-}
-
-class BinaryExpression extends ASTNode {
-    constructor(left, operator, right, loc = null) {
-        super('BinaryExpression', loc)
-        this.left = left
-        this.operator = operator
-        this.right = right
-    }
-}
-
-class UnaryExpression extends ASTNode {
-    constructor(operator, argument, loc = null) {
-        super('UnaryExpression', loc)
-        this.operator = operator
-        this.argument = argument
-    }
-}
-
-class GridTemplate extends ASTNode {
-    constructor(rows, columns, areas = null, loc = null) {
-        super('GridTemplate', loc)
-        this.rows = rows
-        this.columns = columns
-        this.areas = areas
-    }
-}
-
-class GridTrack extends ASTNode {
-    constructor(size, lineNames = [], loc = null) {
-        super('GridTrack', loc)
-        this.size = size
-        this.lineNames = lineNames
-    }
-}
-
-class GridArea extends ASTNode {
-    constructor(name, loc = null) {
-        super('GridArea', loc)
-        this.name = name
-    }
-}
-
-class RepeatFunction extends ASTNode {
-    constructor(count, tracks, loc = null) {
-        super('RepeatFunction', loc)
-        this.count = count
-        this.tracks = tracks
-    }
-}
-
-class MinMaxFunction extends ASTNode {
-    constructor(min, max, loc = null) {
-        super('MinMaxFunction', loc)
-        this.min = min
-        this.max = max
-    }
-}
-
-class FitContentFunction extends ASTNode {
-    constructor(value, loc = null) {
-        super('FitContentFunction', loc)
-        this.value = value
-    }
-}
-
-class ShapeValue extends ASTNode {
-    constructor(shapeType, args, loc = null) {
-        super('ShapeValue', loc)
-        this.shapeType = shapeType
-        this.args = args
-    }
-}
-
-class ImageValue extends ASTNode {
-    constructor(imageType, value, loc = null) {
-        super('ImageValue', loc)
-        this.imageType = imageType
-        this.value = value
-    }
-}
-
-class Ratio extends ASTNode {
-    constructor(width, height, loc = null) {
-        super('Ratio', loc)
-        this.width = width
-        this.height = height
-    }
-}
-
-class Comment extends ASTNode {
-    constructor(value, loc = null) {
-        super('Comment', loc)
-        this.value = value
-    }
-}
-
-class EtherAlias extends ASTNode {
-    constructor(alias, expandedDeclarations, loc = null) {
-        super('EtherAlias', loc)
-        this.alias = alias
-        this.expandedDeclarations = expandedDeclarations
-    }
-}
-
-class EtherCondition extends ASTNode {
-    constructor(condition, rules, elseRules = null, loc = null) {
-        super('EtherCondition', loc)
-        this.condition = condition
-        this.rules = rules
-        this.elseRules = elseRules
-    }
-}
-
-class EtherState extends ASTNode {
-    constructor(state, declarations, loc = null) {
-        super('EtherState', loc)
-        this.state = state
-        this.declarations = declarations
-    }
-}
-
-module.exports = {
-    ASTNode,
-    StyleSheet,
-    Rule,
-    Selector,
-    SelectorList,
-    SimpleSelector,
-    CompoundSelector,
-    ComplexSelector,
-    PseudoClassSelector,
-    PseudoElementSelector,
-    AttributeSelector,
-    Declaration,
-    Property,
-    Value,
-    ValueList,
-    NumberValue,
-    PercentageValue,
-    ColorValue,
-    FunctionCall,
-    Identifier,
-    StringValue,
-    UrlValue,
-    Variable,
-    CustomProperty,
-    MediaQuery,
-    MediaCondition,
-    ContainerQuery,
-    SupportsRule,
-    LayerRule,
-    KeyframesRule,
-    Keyframe,
-    FontFaceRule,
-    ImportRule,
-    PageRule,
-    PropertyRule,
-    CounterStyleRule,
-    ScopeRule,
-    StartingStyleRule,
-    NestingRule,
-    GradientValue,
-    ColorStop,
-    TransformValue,
-    FilterValue,
-    TimingFunction,
-    CalcExpression,
-    BinaryExpression,
-    UnaryExpression,
-    GridTemplate,
-    GridTrack,
-    GridArea,
-    RepeatFunction,
-    MinMaxFunction,
-    FitContentFunction,
-    ShapeValue,
-    ImageValue,
-    Ratio,
-    Comment,
-    EtherAlias,
-    EtherCondition,
-    EtherState
-}