← Back to branch summary

~ubuntu-branches/ubuntu/utopic/moodle/utopic

« back to all changes in this revision

Viewing changes to lib/yuilib/3.9.1/build/selector-css3/selector-css3-debug.js

  • Committer: Package Import Robot
  • Author(s): Thijs Kinkhorst
  • Date: 2014-05-12 16:10:38 UTC
  • mfrom: (36.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20140512161038-puyqf65k4e0s8ytz
Tags: 2.6.3-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/yuilib/3.9.1/build/selector-css3/selector-css3-debug.js
1
 
/* YUI 3.9.1 (build 5852) Copyright 2013 Yahoo! Inc. http://yuilibrary.com/license/ */
2
 
YUI.add('selector-css3', function (Y, NAME) {
3
 
 
4
 
/**
5
 
 * The selector css3 module provides support for css3 selectors.
6
 
 * @module dom
7
 
 * @submodule selector-css3
8
 
 * @for Selector
9
 
 */
10
 
 
11
 
/*
12
 
    an+b = get every _a_th node starting at the _b_th
13
 
    0n+b = no repeat ("0" and "n" may both be omitted (together) , e.g. "0n+1" or "1", not "0+1"), return only the _b_th element
14
 
    1n+b =  get every element starting from b ("1" may may be omitted, e.g. "1n+0" or "n+0" or "n")
15
 
    an+0 = get every _a_th element, "0" may be omitted 
16
 
*/
17
 
 
18
 
Y.Selector._reNth = /^(?:([\-]?\d*)(n){1}|(odd|even)$)*([\-+]?\d*)$/;
19
 
 
20
 
Y.Selector._getNth = function(node, expr, tag, reverse) {
21
 
    Y.Selector._reNth.test(expr);
22
 
    var a = parseInt(RegExp.$1, 10), // include every _a_ elements (zero means no repeat, just first _a_)
23
 
        n = RegExp.$2, // "n"
24
 
        oddeven = RegExp.$3, // "odd" or "even"
25
 
        b = parseInt(RegExp.$4, 10) || 0, // start scan from element _b_
26
 
        result = [],
27
 
        siblings = Y.DOM._children(node.parentNode, tag),
28
 
        op;
29
 
 
30
 
    if (oddeven) {
31
 
        a = 2; // always every other
32
 
        op = '+';
33
 
        n = 'n';
34
 
        b = (oddeven === 'odd') ? 1 : 0;
35
 
    } else if ( isNaN(a) ) {
36
 
        a = (n) ? 1 : 0; // start from the first or no repeat
37
 
    }
38
 
 
39
 
    if (a === 0) { // just the first
40
 
        if (reverse) {
41
 
            b = siblings.length - b + 1; 
42
 
        }
43
 
 
44
 
        if (siblings[b - 1] === node) {
45
 
            return true;
46
 
        } else {
47
 
            return false;
48
 
        }
49
 
 
50
 
    } else if (a < 0) {
51
 
        reverse = !!reverse;
52
 
        a = Math.abs(a);
53
 
    }
54
 
 
55
 
    if (!reverse) {
56
 
        for (var i = b - 1, len = siblings.length; i < len; i += a) {
57
 
            if ( i >= 0 && siblings[i] === node ) {
58
 
                return true;
59
 
            }
60
 
        }
61
 
    } else {
62
 
        for (var i = siblings.length - b, len = siblings.length; i >= 0; i -= a) {
63
 
            if ( i < len && siblings[i] === node ) {
64
 
                return true;
65
 
            }
66
 
        }
67
 
    }
68
 
    return false;
69
 
};
70
 
 
71
 
Y.mix(Y.Selector.pseudos, {
72
 
    'root': function(node) {
73
 
        return node === node.ownerDocument.documentElement;
74
 
    },
75
 
 
76
 
    'nth-child': function(node, expr) {
77
 
        return Y.Selector._getNth(node, expr);
78
 
    },
79
 
 
80
 
    'nth-last-child': function(node, expr) {
81
 
        return Y.Selector._getNth(node, expr, null, true);
82
 
    },
83
 
 
84
 
    'nth-of-type': function(node, expr) {
85
 
        return Y.Selector._getNth(node, expr, node.tagName);
86
 
    },
87
 
     
88
 
    'nth-last-of-type': function(node, expr) {
89
 
        return Y.Selector._getNth(node, expr, node.tagName, true);
90
 
    },
91
 
     
92
 
    'last-child': function(node) {
93
 
        var children = Y.DOM._children(node.parentNode);
94
 
        return children[children.length - 1] === node;
95
 
    },
96
 
 
97
 
    'first-of-type': function(node) {
98
 
        return Y.DOM._children(node.parentNode, node.tagName)[0] === node;
99
 
    },
100
 
     
101
 
    'last-of-type': function(node) {
102
 
        var children = Y.DOM._children(node.parentNode, node.tagName);
103
 
        return children[children.length - 1] === node;
104
 
    },
105
 
     
106
 
    'only-child': function(node) {
107
 
        var children = Y.DOM._children(node.parentNode);
108
 
        return children.length === 1 && children[0] === node;
109
 
    },
110
 
 
111
 
    'only-of-type': function(node) {
112
 
        var children = Y.DOM._children(node.parentNode, node.tagName);
113
 
        return children.length === 1 && children[0] === node;
114
 
    },
115
 
 
116
 
    'empty': function(node) {
117
 
        return node.childNodes.length === 0;
118
 
    },
119
 
 
120
 
    'not': function(node, expr) {
121
 
        return !Y.Selector.test(node, expr);
122
 
    },
123
 
 
124
 
    'contains': function(node, expr) {
125
 
        var text = node.innerText || node.textContent || '';
126
 
        return text.indexOf(expr) > -1;
127
 
    },
128
 
 
129
 
    'checked': function(node) {
130
 
        return (node.checked === true || node.selected === true);
131
 
    },
132
 
 
133
 
    enabled: function(node) {
134
 
        return (node.disabled !== undefined && !node.disabled);
135
 
    },
136
 
 
137
 
    disabled: function(node) {
138
 
        return (node.disabled);
139
 
    }
140
 
});
141
 
 
142
 
Y.mix(Y.Selector.operators, {
143
 
    '^=': '^{val}', // Match starts with value
144
 
    '$=': '{val}$', // Match ends with value
145
 
    '*=': '{val}' // Match contains value as substring 
146
 
});
147
 
 
148
 
Y.Selector.combinators['~'] = {
149
 
    axis: 'previousSibling'
150
 
};
151
 
 
152
 
 
153
 
}, '3.9.1', {"requires": ["selector-native", "selector-css2"]});