Tasks »
-
20 |
-
22 |
23 |
25 | A pending task (even position)
27 |
28 |
23 |
25 | A pending task (even position)
27 |
20 |
21 | A pending task (even position)
22 |
25 |
26 | Another pending task (odd position)
27 |
30 |
31 | A done task (even position)
32 |
35 |
36 | Another done task (odd position)
37 |
40 |
41 | An in progress pending task (even position)
42 |
45 |
46 | Another in progress pending task (odd position)
47 |
50 |
51 | An in progress done task (even position)
52 |
55 |
56 | Another in progress done task (odd position)
57 |
20 |
21 | A pending task (even position)
22 |
25 |
26 | Another pending task (odd position)
27 |
30 |
31 | A done task (even position)
32 |
35 |
36 | Another done task (odd position)
37 |
40 |
41 | An in progress pending task (even position)
42 |
45 |
46 | Another in progress pending task (odd position)
47 |
50 |
51 | An in progress done task (even position)
52 |
55 |
56 | Another in progress done task (odd position)
57 |
19 |
20 | A pending task (even position)
21 |
24 |
25 | Another pending task (odd position)
26 |
29 |
30 | A done task (even position)
31 |
34 |
35 | Another done task (odd position)
36 |
39 |
40 | An in progress pending task (even position)
41 |
44 |
45 | Another in progress pending task (odd position)
46 |
49 |
50 | An in progress done task (even position)
51 |
54 |
55 | Another in progress done task (odd position)
56 |
22 |
23 | A pending task (even position)
24 |
27 |
28 | Another pending task (odd position)
29 |
32 |
33 | A done task (even position)
34 |
37 |
38 | Another done task (odd position)
39 |
42 |
43 | An in progress pending task (even position)
44 |
47 |
48 | Another in progress pending task (odd position)
49 |
52 |
53 | An in progress done task (even position)
54 |
57 |
58 | Another in progress done task (odd position)
59 | opts.delay milliseconds.
119 | * @requires lastTime
120 | * @requires now()
121 | * @requires tokenRegExp
122 | * @requires opts
123 | * @requires rng
124 | * @inner
125 | * @author julrich
126 | * @since 1.0
127 | */
128 | function processNextToken() {
129 | var timeElapsed = now() - lastTime; // Work-around for Firefox "bug": setTimeout can fire before the timeout
130 | if (timeElapsed >= opts.delay) {
131 | var match = tokenRegExp.exec(sequence);
132 | if ( match !== null ) {
133 | var s = match[0];
134 | (localkeys[s] || $.simulate.prototype.simulateKeySequence.defaults[s] || $.simulate.prototype.simulateKeySequence.defaults.simplechar)(rng, s, opts);
135 | setTimeout(processNextToken, opts.delay);
136 | }
137 | else {
138 | sequenceFinished();
139 | }
140 | lastTime = now();
141 | }
142 | else {
143 | setTimeout(processNextToken, opts.delay - timeElapsed);
144 | }
145 | }
146 |
147 | if (!opts.delay || opts.delay <= 0) {
148 | // Run as fast as possible
149 | sequence.replace(/\{[^}]*\}|[^{]+/g, function(s){
150 | (localkeys[s] || $.simulate.prototype.simulateKeySequence.defaults[s] || $.simulate.prototype.simulateKeySequence.defaults.simplechar)(rng, s, opts);
151 | });
152 | sequenceFinished();
153 | }
154 | else {
155 | var tokenRegExp = /\{[^}]*\}|[^{]/g; // This matches curly bracket expressions or single characters
156 | var now = Date.now || function() { return new Date().getTime(); },
157 | lastTime = now();
158 |
159 | processNextToken();
160 | }
161 |
162 | }
163 | });
164 |
165 | $.extend($.simulate.prototype.simulateKeySequence.prototype,
166 |
167 | /**
168 | * @lends $.simulate.prototype.simulateKeySequence.prototype
169 | */
170 | {
171 |
172 | /**
173 | * Maps special character char codes to IE key codes (covers IE and Webkit)
174 | * @author julrich
175 | * @since 1.0
176 | */
177 | IEKeyCodeTable: {
178 | 33: 49, // ! -> 1
179 | 64: 50, // @ -> 2
180 | 35: 51, // # -> 3
181 | 36: 52, // $ -> 4
182 | 37: 53, // % -> 5
183 | 94: 54, // ^ -> 6
184 | 38: 55, // & -> 7
185 | 42: 56, // * -> 8
186 | 40: 57, // ( -> 9
187 | 41: 48, // ) -> 0
188 |
189 | 59: 186, // ; -> 186
190 | 58: 186, // : -> 186
191 | 61: 187, // = -> 187
192 | 43: 187, // + -> 187
193 | 44: 188, // , -> 188
194 | 60: 188, // < -> 188
195 | 45: 189, // - -> 189
196 | 95: 189, // _ -> 189
197 | 46: 190, // . -> 190
198 | 62: 190, // > -> 190
199 | 47: 191, // / -> 191
200 | 63: 191, // ? -> 191
201 | 96: 192, // ` -> 192
202 | 126: 192, // ~ -> 192
203 | 91: 219, // [ -> 219
204 | 123: 219, // { -> 219
205 | 92: 220, // \ -> 220
206 | 124: 220, // | -> 220
207 | 93: 221, // ] -> 221
208 | 125: 221, // } -> 221
209 | 39: 222, // ' -> 222
210 | 34: 222 // " -> 222
211 | },
212 |
213 | /**
214 | * Tries to convert character codes to key codes.
215 | * @param {Numeric} character - A character code
216 | * @returns {Numeric} The key code corresponding to the given character code,
217 | * based on the key code table of InternetExplorer. If no corresponding key code
218 | * could be found (which will be the case for all special characters except the common
219 | * ones), the character code itself is returned. However, keyCode === charCode
220 | * does not imply that no key code was found because some key codes are identical to the
221 | * character codes (e.g. for uppercase characters).
222 | * @requires $.simulate.prototype.simulateKeySequence.prototype.IEKeyCodeTable
223 | * @see $.simulate.prototype.simulateKeySequence.prototype.IEKeyCodeTable
224 | * @author julrich
225 | * @since 1.0
226 | */
227 | charToKeyCode: function(character) {
228 | var specialKeyCodeTable = $.simulate.prototype.simulateKeySequence.prototype.IEKeyCodeTable;
229 | var charCode = character.charCodeAt(0);
230 |
231 | if (charCode >= 64 && charCode <= 90 || charCode >= 48 && charCode <= 57) {
232 | // A-Z and 0-9
233 | return charCode;
234 | }
235 | else if (charCode >= 97 && charCode <= 122) {
236 | // a-z -> A-Z
237 | return character.toUpperCase().charCodeAt(0);
238 | }
239 | else if (specialKeyCodeTable[charCode] !== undefined) {
240 | return specialKeyCodeTable[charCode];
241 | }
242 | else {
243 | return charCode;
244 | }
245 | }
246 | });
247 |
248 | // add the functions publicly so they can be overridden
249 | $.simulate.prototype.simulateKeySequence.defaults = {
250 |
251 | /**
252 | * Simulates key strokes of "normal" characters (i.e. non-special sequences).
253 | * @param {Object} rng - bililiteRange object of the simulation target element.
254 | * @param {String} s - String of (simple) characters to be simulated.
255 | * @param {Object} opts - The key-sequence options.
256 | * @author Daniel Wachsstock, julrich
257 | * @since 1.0
258 | */
259 | simplechar: function (rng, s, opts){
260 | rng.text(s, 'end');
261 | if (opts.triggerKeyEvents) {
262 | for (var i =0; i < s.length; i += 1){
263 | var charCode = s.charCodeAt(i);
264 | var keyCode = $.simulate.prototype.simulateKeySequence.prototype.charToKeyCode(s.charAt(i));
265 | // a bit of cheating: rng._el is the element associated with rng.
266 | $(rng._el).simulate('keydown', {keyCode: keyCode});
267 | $(rng._el).simulate('keypress', {keyCode: charCode, which: charCode, charCode: charCode});
268 | $(rng._el).simulate('keyup', {keyCode: keyCode});
269 | }
270 | }
271 | },
272 |
273 | /**
274 | * Simulates key strokes of a curly opening bracket.
275 | * @param {Object} rng - bililiteRange object of the simulation target element.
276 | * @param {String} s - Ignored.
277 | * @param {Object} opts - The key-sequence options.
278 | * @author Daniel Wachsstock, julrich
279 | * @since 1.0
280 | */
281 | '{{}': function (rng, s, opts){
282 | $.simulate.prototype.simulateKeySequence.defaults.simplechar(rng, '{', opts);
283 | },
284 |
285 | /**
286 | * Simulates hitting the enter button.
287 | * @param {Object} rng - bililiteRange object of the simulation target element.
288 | * @param {String} s - Ignored.
289 | * @param {Object} opts - The key-sequence options.
290 | * @author Daniel Wachsstock, julrich
291 | * @since 1.0
292 | */
293 | '{enter}': function (rng, s, opts){
294 | rng.insertEOL();
295 | rng.select();
296 | if (opts.triggerKeyEvents === true) {
297 | $(rng._el).simulate('keydown', {keyCode: 13});
298 | $(rng._el).simulate('keypress', {keyCode: 13, which: 13, charCode: 13});
299 | $(rng._el).simulate('keyup', {keyCode: 13});
300 | }
301 | },
302 |
303 | /**
304 | * Simulates hitting the backspace button.
305 | * @param {Object} rng - bililiteRange object of the simulation target element.
306 | * @param {String} s - Ignored.
307 | * @param {Object} opts - The key-sequence options.
308 | * @author Daniel Wachsstock, julrich
309 | * @since 1.0
310 | */
311 | '{backspace}': function (rng, s, opts){
312 | var b = rng.bounds();
313 | if (b[0] === b[1]) { rng.bounds([b[0]-1, b[0]]); } // no characters selected; it's just an insertion point. Remove the previous character
314 | rng.text('', 'end'); // delete the characters and update the selection
315 | if (opts.triggerKeyEvents === true) {
316 | $(rng._el).simulate('keydown', {keyCode: 8});
317 | $(rng._el).simulate('keyup', {keyCode: 8});
318 | }
319 | },
320 |
321 | /**
322 | * Simulates hitting the delete button.
323 | * @param {Object} rng - bililiteRange object of the simulation target element.
324 | * @param {String} s - Ignored.
325 | * @param {Object} opts - The key-sequence options.
326 | * @author Daniel Wachsstock, julrich
327 | * @since 1.0
328 | */
329 | '{del}': function (rng, s, opts){
330 | var b = rng.bounds();
331 | if (b[0] === b[1]) { rng.bounds([b[0], b[0]+1]); } // no characters selected; it's just an insertion point. Remove the next character
332 | rng.text('', 'end'); // delete the characters and update the selection
333 | if (opts.triggerKeyEvents === true) {
334 | $(rng._el).simulate('keydown', {keyCode: 46});
335 | $(rng._el).simulate('keyup', {keyCode: 46});
336 | }
337 | },
338 |
339 | /**
340 | * Simulates hitting the right arrow button.
341 | * @param {Object} rng - bililiteRange object of the simulation target element.
342 | * @param {String} s - Ignored.
343 | * @param {Object} opts - The key-sequence options.
344 | * @author Daniel Wachsstock, julrich
345 | * @since 1.0
346 | */
347 | '{rightarrow}': function (rng, s, opts){
348 | var b = rng.bounds();
349 | if (b[0] === b[1]) { b[1] += 1; } // no characters selected; it's just an insertion point. Move to the right
350 | rng.bounds([b[1], b[1]]).select();
351 | if (opts.triggerKeyEvents === true) {
352 | $(rng._el).simulate('keydown', {keyCode: 39});
353 | $(rng._el).simulate('keyup', {keyCode: 39});
354 | }
355 | },
356 |
357 | /**
358 | * Simulates hitting the left arrow button.
359 | * @param {Object} rng - bililiteRange object of the simulation target element.
360 | * @param {String} s - Ignored.
361 | * @param {Object} opts - The key-sequence options.
362 | * @author Daniel Wachsstock, julrich
363 | * @since 1.0
364 | */
365 | '{leftarrow}': function (rng, s, opts){
366 | var b = rng.bounds();
367 | if (b[0] === b[1]) { b[0] -= 1; } // no characters selected; it's just an insertion point. Move to the left
368 | rng.bounds([b[0], b[0]]).select();
369 | if (opts.triggerKeyEvents === true) {
370 | $(rng._el).simulate('keydown', {keyCode: 37});
371 | $(rng._el).simulate('keyup', {keyCode: 37});
372 | }
373 | },
374 |
375 | /**
376 | * Selects all characters in the target element.
377 | * @param {Object} rng - bililiteRange object of the simulation target element.
378 | * @author Daniel Wachsstock, julrich
379 | * @since 1.0
380 | */
381 | '{selectall}' : function (rng){
382 | rng.bounds('all').select();
383 | }
384 | };
385 |
386 | })(jQuery);
--------------------------------------------------------------------------------
/vendor/almond.js:
--------------------------------------------------------------------------------
1 | /**
2 | * almond 0.2.5 Copyright (c) 2011-2012, The Dojo Foundation All Rights Reserved.
3 | * Available via the MIT or new BSD license.
4 | * see: http://github.com/jrburke/almond for details
5 | */
6 | //Going sloppy to avoid 'use strict' string cost, but strict practices should
7 | //be followed.
8 | /*jslint sloppy: true */
9 | /*global setTimeout: false */
10 |
11 | var requirejs, require, define;
12 | (function (undef) {
13 | var main, req, makeMap, handlers,
14 | defined = {},
15 | waiting = {},
16 | config = {},
17 | defining = {},
18 | hasOwn = Object.prototype.hasOwnProperty,
19 | aps = [].slice;
20 |
21 | function hasProp(obj, prop) {
22 | return hasOwn.call(obj, prop);
23 | }
24 |
25 | /**
26 | * Given a relative module name, like ./something, normalize it to
27 | * a real name that can be mapped to a path.
28 | * @param {String} name the relative name
29 | * @param {String} baseName a real name that the name arg is relative
30 | * to.
31 | * @returns {String} normalized name
32 | */
33 | function normalize(name, baseName) {
34 | var nameParts, nameSegment, mapValue, foundMap,
35 | foundI, foundStarMap, starI, i, j, part,
36 | baseParts = baseName && baseName.split("/"),
37 | map = config.map,
38 | starMap = (map && map['*']) || {};
39 |
40 | //Adjust any relative paths.
41 | if (name && name.charAt(0) === ".") {
42 | //If have a base name, try to normalize against it,
43 | //otherwise, assume it is a top-level require that will
44 | //be relative to baseUrl in the end.
45 | if (baseName) {
46 | //Convert baseName to array, and lop off the last part,
47 | //so that . matches that "directory" and not name of the baseName's
48 | //module. For instance, baseName of "one/two/three", maps to
49 | //"one/two/three.js", but we want the directory, "one/two" for
50 | //this normalization.
51 | baseParts = baseParts.slice(0, baseParts.length - 1);
52 |
53 | name = baseParts.concat(name.split("/"));
54 |
55 | //start trimDots
56 | for (i = 0; i < name.length; i += 1) {
57 | part = name[i];
58 | if (part === ".") {
59 | name.splice(i, 1);
60 | i -= 1;
61 | } else if (part === "..") {
62 | if (i === 1 && (name[2] === '..' || name[0] === '..')) {
63 | //End of the line. Keep at least one non-dot
64 | //path segment at the front so it can be mapped
65 | //correctly to disk. Otherwise, there is likely
66 | //no path mapping for a path starting with '..'.
67 | //This can still fail, but catches the most reasonable
68 | //uses of ..
69 | break;
70 | } else if (i > 0) {
71 | name.splice(i - 1, 2);
72 | i -= 2;
73 | }
74 | }
75 | }
76 | //end trimDots
77 |
78 | name = name.join("/");
79 | } else if (name.indexOf('./') === 0) {
80 | // No baseName, so this is ID is resolved relative
81 | // to baseUrl, pull off the leading dot.
82 | name = name.substring(2);
83 | }
84 | }
85 |
86 | //Apply map config if available.
87 | if ((baseParts || starMap) && map) {
88 | nameParts = name.split('/');
89 |
90 | for (i = nameParts.length; i > 0; i -= 1) {
91 | nameSegment = nameParts.slice(0, i).join("/");
92 |
93 | if (baseParts) {
94 | //Find the longest baseName segment match in the config.
95 | //So, do joins on the biggest to smallest lengths of baseParts.
96 | for (j = baseParts.length; j > 0; j -= 1) {
97 | mapValue = map[baseParts.slice(0, j).join('/')];
98 |
99 | //baseName segment has config, find if it has one for
100 | //this name.
101 | if (mapValue) {
102 | mapValue = mapValue[nameSegment];
103 | if (mapValue) {
104 | //Match, update name to the new value.
105 | foundMap = mapValue;
106 | foundI = i;
107 | break;
108 | }
109 | }
110 | }
111 | }
112 |
113 | if (foundMap) {
114 | break;
115 | }
116 |
117 | //Check for a star map match, but just hold on to it,
118 | //if there is a shorter segment match later in a matching
119 | //config, then favor over this star map.
120 | if (!foundStarMap && starMap && starMap[nameSegment]) {
121 | foundStarMap = starMap[nameSegment];
122 | starI = i;
123 | }
124 | }
125 |
126 | if (!foundMap && foundStarMap) {
127 | foundMap = foundStarMap;
128 | foundI = starI;
129 | }
130 |
131 | if (foundMap) {
132 | nameParts.splice(0, foundI, foundMap);
133 | name = nameParts.join('/');
134 | }
135 | }
136 |
137 | return name;
138 | }
139 |
140 | function makeRequire(relName, forceSync) {
141 | return function () {
142 | //A version of a require function that passes a moduleName
143 | //value for items that may need to
144 | //look up paths relative to the moduleName
145 | return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
146 | };
147 | }
148 |
149 | function makeNormalize(relName) {
150 | return function (name) {
151 | return normalize(name, relName);
152 | };
153 | }
154 |
155 | function makeLoad(depName) {
156 | return function (value) {
157 | defined[depName] = value;
158 | };
159 | }
160 |
161 | function callDep(name) {
162 | if (hasProp(waiting, name)) {
163 | var args = waiting[name];
164 | delete waiting[name];
165 | defining[name] = true;
166 | main.apply(undef, args);
167 | }
168 |
169 | if (!hasProp(defined, name) && !hasProp(defining, name)) {
170 | throw new Error('No ' + name);
171 | }
172 | return defined[name];
173 | }
174 |
175 | //Turns a plugin!resource to [plugin, resource]
176 | //with the plugin being undefined if the name
177 | //did not have a plugin prefix.
178 | function splitPrefix(name) {
179 | var prefix,
180 | index = name ? name.indexOf('!') : -1;
181 | if (index > -1) {
182 | prefix = name.substring(0, index);
183 | name = name.substring(index + 1, name.length);
184 | }
185 | return [prefix, name];
186 | }
187 |
188 | /**
189 | * Makes a name map, normalizing the name, and using a plugin
190 | * for normalization if necessary. Grabs a ref to plugin
191 | * too, as an optimization.
192 | */
193 | makeMap = function (name, relName) {
194 | var plugin,
195 | parts = splitPrefix(name),
196 | prefix = parts[0];
197 |
198 | name = parts[1];
199 |
200 | if (prefix) {
201 | prefix = normalize(prefix, relName);
202 | plugin = callDep(prefix);
203 | }
204 |
205 | //Normalize according
206 | if (prefix) {
207 | if (plugin && plugin.normalize) {
208 | name = plugin.normalize(name, makeNormalize(relName));
209 | } else {
210 | name = normalize(name, relName);
211 | }
212 | } else {
213 | name = normalize(name, relName);
214 | parts = splitPrefix(name);
215 | prefix = parts[0];
216 | name = parts[1];
217 | if (prefix) {
218 | plugin = callDep(prefix);
219 | }
220 | }
221 |
222 | //Using ridiculous property names for space reasons
223 | return {
224 | f: prefix ? prefix + '!' + name : name, //fullName
225 | n: name,
226 | pr: prefix,
227 | p: plugin
228 | };
229 | };
230 |
231 | function makeConfig(name) {
232 | return function () {
233 | return (config && config.config && config.config[name]) || {};
234 | };
235 | }
236 |
237 | handlers = {
238 | require: function (name) {
239 | return makeRequire(name);
240 | },
241 | exports: function (name) {
242 | var e = defined[name];
243 | if (typeof e !== 'undefined') {
244 | return e;
245 | } else {
246 | return (defined[name] = {});
247 | }
248 | },
249 | module: function (name) {
250 | return {
251 | id: name,
252 | uri: '',
253 | exports: defined[name],
254 | config: makeConfig(name)
255 | };
256 | }
257 | };
258 |
259 | main = function (name, deps, callback, relName) {
260 | var cjsModule, depName, ret, map, i,
261 | args = [],
262 | usingExports;
263 |
264 | //Use name if no relName
265 | relName = relName || name;
266 |
267 | //Call the callback to define the module, if necessary.
268 | if (typeof callback === 'function') {
269 |
270 | //Pull out the defined dependencies and pass the ordered
271 | //values to the callback.
272 | //Default to [require, exports, module] if no deps
273 | deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
274 | for (i = 0; i < deps.length; i += 1) {
275 | map = makeMap(deps[i], relName);
276 | depName = map.f;
277 |
278 | //Fast path CommonJS standard dependencies.
279 | if (depName === "require") {
280 | args[i] = handlers.require(name);
281 | } else if (depName === "exports") {
282 | //CommonJS module spec 1.1
283 | args[i] = handlers.exports(name);
284 | usingExports = true;
285 | } else if (depName === "module") {
286 | //CommonJS module spec 1.1
287 | cjsModule = args[i] = handlers.module(name);
288 | } else if (hasProp(defined, depName) ||
289 | hasProp(waiting, depName) ||
290 | hasProp(defining, depName)) {
291 | args[i] = callDep(depName);
292 | } else if (map.p) {
293 | map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
294 | args[i] = defined[depName];
295 | } else {
296 | throw new Error(name + ' missing ' + depName);
297 | }
298 | }
299 |
300 | ret = callback.apply(defined[name], args);
301 |
302 | if (name) {
303 | //If setting exports via "module" is in play,
304 | //favor that over return value and exports. After that,
305 | //favor a non-undefined return value over exports use.
306 | if (cjsModule && cjsModule.exports !== undef &&
307 | cjsModule.exports !== defined[name]) {
308 | defined[name] = cjsModule.exports;
309 | } else if (ret !== undef || !usingExports) {
310 | //Use the return value from the function.
311 | defined[name] = ret;
312 | }
313 | }
314 | } else if (name) {
315 | //May just be an object definition for the module. Only
316 | //worry about defining if have a module name.
317 | defined[name] = callback;
318 | }
319 | };
320 |
321 | requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
322 | if (typeof deps === "string") {
323 | if (handlers[deps]) {
324 | //callback in this case is really relName
325 | return handlers[deps](callback);
326 | }
327 | //Just return the module wanted. In this scenario, the
328 | //deps arg is the module name, and second arg (if passed)
329 | //is just the relName.
330 | //Normalize module name, if it contains . or ..
331 | return callDep(makeMap(deps, callback).f);
332 | } else if (!deps.splice) {
333 | //deps is a config object, not an array.
334 | config = deps;
335 | if (callback.splice) {
336 | //callback is an array, which means it is a dependency list.
337 | //Adjust args if there are dependencies
338 | deps = callback;
339 | callback = relName;
340 | relName = null;
341 | } else {
342 | deps = undef;
343 | }
344 | }
345 |
346 | //Support require(['a'])
347 | callback = callback || function () {};
348 |
349 | //If relName is a function, it is an errback handler,
350 | //so remove it.
351 | if (typeof relName === 'function') {
352 | relName = forceSync;
353 | forceSync = alt;
354 | }
355 |
356 | //Simulate async callback;
357 | if (forceSync) {
358 | main(undef, deps, callback, relName);
359 | } else {
360 | //Using a non-zero value because of concern for what old browsers
361 | //do, and latest browsers "upgrade" to 4 if lower value is used:
362 | //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
363 | //If want a value immediately, use require('id') instead -- something
364 | //that works in almond on the global level, but not guaranteed and
365 | //unlikely to work in other AMD implementations.
366 | setTimeout(function () {
367 | main(undef, deps, callback, relName);
368 | }, 4);
369 | }
370 |
371 | return req;
372 | };
373 |
374 | /**
375 | * Just drops the config on the floor, but returns req in case
376 | * the config return value is used.
377 | */
378 | req.config = function (cfg) {
379 | config = cfg;
380 | if (config.deps) {
381 | req(config.deps, config.callback);
382 | }
383 | return req;
384 | };
385 |
386 | define = function (name, deps, callback) {
387 |
388 | //This module may not have dependencies
389 | if (!deps.splice) {
390 | //deps is not an array, so probably means
391 | //an object literal or factory function for
392 | //the value. Adjust args.
393 | callback = deps;
394 | deps = [];
395 | }
396 |
397 | if (!hasProp(defined, name) && !hasProp(waiting, name)) {
398 | waiting[name] = [name, deps, callback];
399 | }
400 | };
401 |
402 | define.amd = {
403 | jQuery: true
404 | };
405 | }());
406 |
--------------------------------------------------------------------------------
/src/test/bdd/vendor/bililiteRange.js:
--------------------------------------------------------------------------------
1 | // Cross-broswer implementation of text ranges and selections
2 | // documentation: http://bililite.com/blog/2011/01/17/cross-browser-text-ranges-and-selections/
3 | // Version: 1.1
4 | // Copyright (c) 2010 Daniel Wachsstock
5 | // MIT license:
6 | // Permission is hereby granted, free of charge, to any person
7 | // obtaining a copy of this software and associated documentation
8 | // files (the "Software"), to deal in the Software without
9 | // restriction, including without limitation the rights to use,
10 | // copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | // copies of the Software, and to permit persons to whom the
12 | // Software is furnished to do so, subject to the following
13 | // conditions:
14 |
15 | // The above copyright notice and this permission notice shall be
16 | // included in all copies or substantial portions of the Software.
17 |
18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
20 | // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 | // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 | // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
24 | // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25 | // OTHER DEALINGS IN THE SOFTWARE.
26 |
27 | (function () {
28 | bililiteRange = function (el, debug) {
29 | var ret;
30 | if (debug) {
31 | ret = new NothingRange(); // Easier to force it to use the no-selection type than to try to find an old browser
32 | } else if (document.selection) {
33 | // Internet Explorer
34 | ret = new IERange();
35 | } else if (window.getSelection && el.setSelectionRange) {
36 | // Standards. Element is an input or textarea
37 | ret = new InputRange();
38 | } else if (window.getSelection) {
39 | // Standards, with any other kind of element
40 | ret = new W3CRange();
41 | } else {
42 | // doesn't support selection
43 | ret = new NothingRange();
44 | }
45 | ret._el = el;
46 | ret._textProp = textProp(el);
47 | ret._bounds = [0, ret.length()];
48 | return ret;
49 | };
50 |
51 | function textProp(el) {
52 | // returns the property that contains the text of the element
53 | if (typeof el.value != 'undefined') return 'value';
54 | if (typeof el.text != 'undefined') return 'text';
55 | if (typeof el.textContent != 'undefined') return 'textContent';
56 | return 'innerText';
57 | }
58 |
59 | // base class
60 | function Range() {
61 | }
62 |
63 | Range.prototype = {
64 | length: function () {
65 | return this._el[this._textProp].replace(/\r/g, '').length; // need to correct for IE's CrLf weirdness
66 | },
67 | bounds: function (s) {
68 | if (s === 'all') {
69 | this._bounds = [0, this.length()];
70 | } else if (s === 'start') {
71 | this._bounds = [0, 0];
72 | } else if (s === 'end') {
73 | this._bounds = [this.length(), this.length()];
74 | } else if (s === 'selection') {
75 | this.bounds('all'); // first select the whole thing for constraining
76 | this._bounds = this._nativeSelection();
77 | } else if (s) {
78 | this._bounds = s; // don't error check now; the element may change at any moment, so constrain it when we need it.
79 | } else {
80 | var b = [
81 | Math.max(0, Math.min(this.length(), this._bounds[0])),
82 | Math.max(0, Math.min(this.length(), this._bounds[1]))
83 | ];
84 | return b; // need to constrain it to fit
85 | }
86 | return this; // allow for chaining
87 | },
88 | select: function () {
89 | this._nativeSelect(this._nativeRange(this.bounds()));
90 | return this; // allow for chaining
91 | },
92 | text: function (text, select) {
93 | if (arguments.length) {
94 | this._nativeSetText(text, this._nativeRange(this.bounds()));
95 | if (select == 'start') {
96 | this.bounds([this._bounds[0], this._bounds[0]]);
97 | this.select();
98 | } else if (select == 'end') {
99 | this.bounds([this._bounds[0] + text.length, this._bounds[0] + text.length]);
100 | this.select();
101 | } else if (select == 'all') {
102 | this.bounds([this._bounds[0], this._bounds[0] + text.length]);
103 | this.select();
104 | }
105 | return this; // allow for chaining
106 | } else {
107 | return this._nativeGetText(this._nativeRange(this.bounds()));
108 | }
109 | },
110 | insertEOL: function () {
111 | this._nativeEOL();
112 | this._bounds = [this._bounds[0] + 1, this._bounds[0] + 1]; // move past the EOL marker
113 | return this;
114 | }
115 | };
116 |
117 | function IERange() {
118 | }
119 |
120 | IERange.prototype = new Range();
121 | IERange.prototype._nativeRange = function (bounds) {
122 | var rng;
123 | if (this._el.tagName == 'INPUT') {
124 | // IE 8 is very inconsistent; textareas have createTextRange but it doesn't work
125 | rng = this._el.createTextRange();
126 | } else {
127 | rng = document.body.createTextRange();
128 | rng.moveToElementText(this._el);
129 | }
130 | if (bounds) {
131 | if (bounds[1] < 0) bounds[1] = 0; // IE tends to run elements out of bounds
132 | if (bounds[0] > this.length()) bounds[0] = this.length();
133 | if (bounds[1] < rng.text.replace(/\r/g, '').length) { // correct for IE's CrLf wierdness
134 | // block-display elements have an invisible, uncounted end of element marker, so we move an extra one and use the current length of the range
135 | rng.moveEnd('character', -1);
136 | rng.moveEnd('character', bounds[1] - rng.text.replace(/\r/g, '').length);
137 | }
138 | if (bounds[0] > 0) rng.moveStart('character', bounds[0]);
139 | }
140 | return rng;
141 | };
142 | IERange.prototype._nativeSelect = function (rng) {
143 | rng.select();
144 | };
145 | IERange.prototype._nativeSelection = function () {
146 | // returns [start, end] for the selection constrained to be in element
147 | var rng = this._nativeRange(); // range of the element to constrain to
148 | var len = this.length();
149 | if (document.selection.type != 'Text') return [len, len]; // append to the end
150 | var sel = document.selection.createRange();
151 | try {
152 | return [
153 | iestart(sel, rng),
154 | ieend(sel, rng)
155 | ];
156 | } catch (e) {
157 | // IE gets upset sometimes about comparing text to input elements, but the selections cannot overlap, so make a best guess
158 | return (sel.parentElement().sourceIndex < this._el.sourceIndex) ? [0, 0] : [len, len];
159 | }
160 | };
161 | IERange.prototype._nativeGetText = function (rng) {
162 | return rng.text.replace(/\r/g, ''); // correct for IE's CrLf weirdness
163 | };
164 | IERange.prototype._nativeSetText = function (text, rng) {
165 | rng.text = text;
166 | };
167 | IERange.prototype._nativeEOL = function () {
168 | if (typeof this._el.value != 'undefined') {
169 | this.text('\n'); // for input and textarea, insert it straight
170 | } else {
171 | this._nativeRange(this.bounds()).pasteHTML('