Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
clone.js	530 B	-rw-rw-r--	2022-08-30 11:49
list.js	8.31 KB	-rw-rw-r--	2022-08-30 11:49
names.js	1.8 KB	-rw-rw-r--	2022-08-30 11:49
translate.js	4.29 KB	-rw-rw-r--	2022-08-30 11:49
translateWithSourceMap.js	7.51 KB	-rw-rw-r--	2022-08-30 11:49
walk.js	4.34 KB	-rw-rw-r--	2022-08-30 11:49

Rename

function each(list) {
    if (list.head === null) {
        return '';
    }

if (list.head === list.tail) {
        return translate(list.head.data);
    }

return list.map(translate).join('');
}

function eachDelim(list, delimeter) {
    if (list.head === null) {
        return '';
    }

if (list.head === list.tail) {
        return translate(list.head.data);
    }

return list.map(translate).join(delimeter);
}

function translate(node) {
    switch (node.type) {
        case 'StyleSheet':
            return each(node.rules);

case 'Atrule':
            var nodes = ['@', node.name];

if (node.expression && !node.expression.sequence.isEmpty()) {
                nodes.push(' ', translate(node.expression));
            }

if (node.block) {
                nodes.push('{', translate(node.block), '}');
            } else {
                nodes.push(';');
            }

return nodes.join('');

case 'Ruleset':
            return translate(node.selector) + '{' + translate(node.block) + '}';

case 'Selector':
            return eachDelim(node.selectors, ',');

case 'SimpleSelector':
            var nodes = node.sequence.map(function(node) {
                // add extra spaces around /deep/ combinator since comment beginning/ending may to be produced
                if (node.type === 'Combinator' && node.name === '/deep/') {
                    return ' ' + translate(node) + ' ';
                }

return translate(node);
            });

return nodes.join('');

case 'Block':
            return eachDelim(node.declarations, ';');

case 'Declaration':
            return translate(node.property) + ':' + translate(node.value);

case 'Property':
            return node.name;

case 'Value':
            return node.important
                ? each(node.sequence) + '!important'
                : each(node.sequence);

case 'Attribute':
            var result = translate(node.name);
            var flagsPrefix = ' ';

if (node.operator !== null) {
                result += node.operator;

if (node.value !== null) {
                    result += translate(node.value);

// space between string and flags is not required
                    if (node.value.type === 'String') {
                        flagsPrefix = '';
                    }
                }
            }

if (node.flags !== null) {
                result += flagsPrefix + node.flags;
            }

return '[' + result + ']';

case 'FunctionalPseudo':
            return ':' + node.name + '(' + eachDelim(node.arguments, ',') + ')';

case 'Function':
            return node.name + '(' + eachDelim(node.arguments, ',') + ')';

case 'Negation':
            return ':not(' + eachDelim(node.sequence, ',') + ')';

case 'Braces':
            return node.open + each(node.sequence) + node.close;

case 'Argument':
        case 'AtruleExpression':
            return each(node.sequence);

case 'Url':
            return 'url(' + translate(node.value) + ')';

case 'Progid':
            return translate(node.value);

case 'Combinator':
            return node.name;

case 'Identifier':
            return node.name;

case 'PseudoClass':
            return ':' + node.name;

case 'PseudoElement':
            return '::' + node.name;

case 'Class':
            return '.' + node.name;

case 'Id':
            return '#' + node.name;

case 'Hash':
            return '#' + node.value;

case 'Dimension':
            return node.value + node.unit;

case 'Nth':
            return node.value;

case 'Number':
            return node.value;

case 'String':
            return node.value;

case 'Operator':
            return node.value;

case 'Raw':
            return node.value;

case 'Unknown':
            return node.value;

case 'Percentage':
            return node.value + '%';

case 'Space':
            return ' ';

case 'Comment':
            return '/*' + node.value + '*/';

default:
            throw new Error('Unknown node type: ' + node.type);
    }
}

module.exports = translate;