@sencha/cmd-linux-64/dist/js/node_modules/fashion/src/parse/ast/Nodes.js

Productivity and performance optimization tool for building applications with Sencha Ext JS

"use strict";

var Fashion = require('../../export/Base.js');
var BaseNode = require('./BaseNode.js');

class Each extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Each(this);
    }

    descend(visitor) {
        visitor.visit(this.list);
        visitor.visit(this.statements);
    }
}

Fashion.apply(Each.prototype, {
    type: 'Each',
    variable: undefined,
    list: undefined,
    statements: undefined
});

class For extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.For(this);
    }

    descend(visitor) {
        visitor.visit(this.start);
        visitor.visit(this.end);
        visitor.visit(this.statements);
    }
}

Fashion.apply(For.prototype, {
    type: 'For',
    variable: undefined,
    start: undefined,
    end: undefined,
    statements: undefined
});

class While extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.While(this);
    }

    descend(visitor) {
        visitor.visit(this.condition);
        visitor.visit(this.statements);
    }
}

Fashion.apply(While.prototype, {
    type: 'While',
    condition: undefined,
    statements: undefined
});

class Charset extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Charset(this);
    }
}

Fashion.apply(Charset.prototype, {
    type: 'Charset'
});

class FunctionNode extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Function(this);
    }

    descend(visitor) {
        visitor.visit(this.func);
        visitor.visit(this.statements);
    }
}

Fashion.apply(FunctionNode.prototype, {
    type: 'Function',
    func: undefined,
    statements: undefined
});

class Ruleset extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Ruleset(this);
    }

    descend(visitor) {
        visitor.visit(this.selectors);
        visitor.visit(this.statements);
    }
}

Fashion.apply(Ruleset.prototype, {
    type: 'Ruleset',
    selectors: undefined,
    statements: undefined,
    acceptsDocs: true
});

class Mixin extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Mixin(this);
    }

    descend(visitor) {
        visitor.visit(this.name);
        visitor.visit(this.statements);
    }
}

Fashion.apply(Mixin.prototype, {
    type: 'Mixin',
    name: undefined,
    statements: undefined
});

class Block extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Block(this);
    }

    descend(visitor) {
        visitor.visit(this.statements);
    }
}

Fashion.apply(Block.prototype, {
    type: 'Block',
    statements: undefined
});

class Include extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Include(this);
    }

    descend(visitor) {
        visitor.visit(this.include);
        this.content && visitor.visit(this.content);
    }
}

Fashion.apply(Include.prototype, {
    type: 'Include',
    include: undefined,
    content: undefined
});

class Assignment extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Assignment(this);
    }

    descend(visitor) {
        visitor.visit(this.expr);
    }
}

Fashion.apply(Assignment.prototype, {
    type: 'Assignment',
    expr: undefined
});

class Declaration extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Declaration(this);
    }

    descend(visitor) {
        visitor.visit(this.value);
    }
}

Fashion.apply(Declaration.prototype, {
    type: 'Declaration',
    property: undefined,
    value: undefined,
    acceptsDocs: true
});

class VariableAssignment extends BaseNode {
    constructor(token, name, value) {
        super(token);
        this.name = name;
        this.value = value;
    }

    doVisit(visitor) {
        visitor.VariableAssignment(this);
    }

    descend(visitor) {
        visitor.visit(this.value);
    }
}

Fashion.apply(VariableAssignment.prototype, {
    type: 'VariableAssignment',
    name: undefined,
    value: undefined,
    valueText: undefined,
    acceptsDocs: true
});

class If extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.If(this);
    }

    descend(visitor) {
        visitor.visit(this.condition);
        visitor.visit(this.statements);
    }
}

Fashion.apply(If.prototype, {
    type: 'If',
    condition: undefined,
    statements: undefined
});

class Else extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Else(this);
    }

    descend(visitor) {
        visitor.visit(this.condition);
        visitor.visit(this.statements);
    }
}

Fashion.apply(Else.prototype, {
    type: 'Else',
    condition: undefined,
    statements: undefined
});

class Return extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Return(this);
    }

    descend(visitor) {
        visitor.visit(this.expr);
    }
}

Fashion.apply(Return.prototype, {
    type: 'Return',
    expr: undefined
});

class Parenthetical extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.ParentheticalExpression(this);
    }

    descend(visitor) {
        visitor.visit(this.expr);
    }
}

Fashion.apply(Parenthetical.prototype, {
    type: 'Parenthetical',
    expr: undefined
});

class SelectorPart extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.SelectorPart(this);
    }

    descend(visitor) {
        visitor.visit(this.value);
    }
}

Fashion.apply(SelectorPart.prototype, {
    type: 'SelectorPart',
    value: undefined
});

class SelectorProperty extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.SelectorProperty(this);
    }

    descend(visitor) {
        visitor.visit(this.property);
        visitor.visit(this.value);
    }
}

Fashion.apply(SelectorProperty.prototype, {
    type: 'SelectorProperty',
    property: undefined,
    value: undefined
});

class CompoundSelector extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.CompoundSelector(this);
    }

    descend(visitor) {
        visitor.visit(this.items);
    }
}

Fashion.apply(CompoundSelector.prototype, {
    type: 'CompoundSelector',
    items: undefined
});

class MultiPartSelector extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.MultiPartSelector(this);
    }

    descend(visitor) {
        visitor.visit(this.items);
    }
}

Fashion.apply(MultiPartSelector.prototype, {
    type: 'MultiPartSelector',
    items: undefined
});

class SelectorList extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.SelectorList(this);
    }

    descend(visitor) {
        visitor.visit(this.items);
    }
}

Fashion.apply(SelectorList.prototype, {
    type: 'SelectorList',
    items: undefined
});

class BinaryExpression extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.BinaryExpression(this);
    }

    descend(visitor) {
        visitor.visit(this.left);
        visitor.visit(this.right);
    }
}

Fashion.apply(BinaryExpression.prototype, {
    type: 'BinaryExpression',
    left: undefined,
    right: undefined
});

class UnaryExpression extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.UnaryExpression(this);
    }

    descend(visitor) {
        visitor.visit(this.expr);
    }
}

Fashion.apply(UnaryExpression.prototype, {
    type: 'UnaryExpression',
    expr: undefined
});

class Variable extends BaseNode {
    constructor(token, name) {
        super(token);
        this.name = name || token.value;
    }

    doVisit(visitor) {
        visitor.Variable(this);
    }
}

Fashion.apply(Variable.prototype, {
    type: 'Variable'
});

class Constant extends BaseNode {
    constructor(token, value) {
        super(token);
        this.value = value || token.value;
    }

    doVisit(visitor) {
        visitor.Constant(this);
    }
}

Fashion.apply(Constant.prototype, {
    type: 'Constant',
    value: undefined
});

class Literal extends Constant {
    constructor (token, value) {
        super(token, value);
    }
}

Fashion.apply(Literal.prototype, {
    dataType: 'Literal'
});

class Number extends Constant {
    constructor (token, value) {
        super(token, value);
    }
}

Fashion.apply(Number.prototype, {
    dataType: 'Number'
});

class String extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
        this.quoteChar = quoteChar !== undefined ? quoteChar : token.quoteChar;
    }
}

Fashion.apply(String.prototype, {
    dataType: 'String',
    quoteChar: undefined
});

class Length extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
    }
}

Fashion.apply(Length.prototype, {
    dataType: 'Length',
    quoteChar: undefined
});

class Time extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
    }
}

Fashion.apply(Time.prototype, {
    dataType: 'Time',
    quoteChar: undefined
});

class Angle extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
    }
}

Fashion.apply(Angle.prototype, {
    dataType: 'Angle',
    quoteChar: undefined
});

class Percentage extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
    }
}

Fashion.apply(Percentage.prototype, {
    dataType: 'Percentage',
    quoteChar: undefined
});

class Color extends Constant {
    constructor (token, value, quoteChar) {
        super(token, value);
    }
}

Fashion.apply(Color.prototype, {
    dataType: 'Color',
    quoteChar: undefined
});

class FunctionCall extends BaseNode {
    constructor(token, id, args) {
        super(token);
        this.id = id;
        this.args = args;
    }

    doVisit(visitor) {
        visitor.FunctionCall(this);
    }

    descend(visitor) {
        visitor.visit(this.args);
    }
}

Fashion.apply(FunctionCall.prototype, {
    type: 'FunctionCall',
    id: undefined,
    args: undefined
});

class Extend extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Extend(this);
    }
}

Fashion.apply(Extend.prototype, {
    type: 'Extend'
});

class List extends BaseNode {
    constructor(token, items, separator) {
        super(token);
        this.items = items;
        this.separator = separator;
    }

    doVisit(visitor) {
        visitor.List(this);
    }

    descend(visitor) {
        visitor.visit(this.items);
    }
}

Fashion.apply(List.prototype, {
    type: 'List',
    items: undefined,
    separator: undefined,
    isFashionListAst: true
});

class Warn extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Warn(this);
    }
}

Fashion.apply(Warn.prototype, {
    type: 'Warn'
});

class Error extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Error(this);
    }
}

Fashion.apply(Error.prototype, {
    type: 'Error'
});

class Debug extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Debug(this);
    }

    descend(visitor) {
        visitor.visit(this.expr);
    }
}

Fashion.apply(Debug.prototype, {
    type: 'Debug',
    expr: undefined
});

class Import extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Import(this);
    }
}

Fashion.apply(Import.prototype, {
    type: 'Import',
    source: undefined
});

class Require extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Require(this);
    }

    descend(visitor) {
        visitor.visit(this.source);
    }
}

Fashion.apply(Require.prototype, {
    type: 'Require',
    source: undefined
});

class Content extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Content(this);
    }
}

Fashion.apply(Content.prototype, {
    type: 'Content'
});

class Debugger extends BaseNode {
    constructor(cfg) {
        super(cfg);
    }

    doVisit(visitor) {
        visitor.Debugger(this);
    }
}

Fashion.apply(Debugger.prototype, {
    type: 'Debugger'
});

module.exports = {
    Each: Each,
    For: For,
    While: While,
    Charset: Charset,
    Function: FunctionNode,
    Ruleset: Ruleset,
    Mixin: Mixin,
    Block: Block,
    Include: Include,
    Assignment: Assignment,
    Declaration: Declaration,
    VariableAssignment: VariableAssignment,
    If: If,
    Else: Else,
    Return: Return,
    Parenthetical: Parenthetical,
    SelectorPart: SelectorPart,
    SelectorProperty: SelectorProperty,
    CompoundSelector: CompoundSelector,
    MultiPartSelector: MultiPartSelector,
    SelectorList: SelectorList,
    BinaryExpression: BinaryExpression,
    UnaryExpression: UnaryExpression,
    Variable: Variable,
    Constant: Constant,
    Literal: Literal,
    Number: Number,
    String: String,
    Length: Length,
    Time: Time,
    Angle: Angle,
    Percentage: Percentage,
    Color: Color,
    FunctionCall: FunctionCall,
    Extend: Extend,
    List: List,
    Warn: Warn,
    Error: Error,
    Debug: Debug,
    Import: Import,
    Require: Require,
    Content: Content,
    Debugger: Debugger
};