Fixed an issue with parentNode being accessed in attr() on disconnected DOM elements.
[jquery.git] / build / js / base2.js
1 // timestamp: Tue, 01 May 2007 19:13:00\r
2 /*\r
3         base2.js - copyright 2007, Dean Edwards\r
4         http://www.opensource.org/licenses/mit-license\r
5 */\r
6 \r
7 var base2 = {};\r
8 \r
9 // You know, writing a javascript library is awfully time consuming.\r
10 \r
11 new function(_) { ////////////////////  BEGIN: CLOSURE  ////////////////////\r
12 \r
13 // =========================================================================\r
14 // base2/Base.js\r
15 // =========================================================================\r
16 \r
17 // version 1.1\r
18 \r
19 var Base = function() {\r
20         // call this method from any other method to invoke that method's ancestor\r
21 };\r
22 \r
23 Base.prototype = {      \r
24         extend: function(source) {\r
25                 if (arguments.length > 1) { // extending with a name/value pair\r
26                         var ancestor = this[source];\r
27                         var value = arguments[1];\r
28                         if (typeof value == "function" && ancestor && /\bbase\b/.test(value)) {\r
29                                 var method = value;                             \r
30                                 value = function() { // override\r
31                                         var previous = this.base;\r
32                                         this.base = ancestor;\r
33                                         var returnValue = method.apply(this, arguments);\r
34                                         this.base = previous;\r
35                                         return returnValue;\r
36                                 };\r
37                                 value.method = method;\r
38                                 value.ancestor = ancestor;\r
39                         }\r
40                         this[source] = value;\r
41                 } else if (source) { // extending with an object literal\r
42                         var extend = Base.prototype.extend;\r
43                         if (Base._prototyping) {\r
44                                 var key, i = 0, members = ["constructor", "toString", "valueOf"];\r
45                                 while (key = members[i++]) if (source[key] != Object.prototype[key]) {\r
46                                         extend.call(this, key, source[key]);\r
47                                 }\r
48                         } else if (typeof this != "function") {\r
49                                 // if the object has a customised extend() method then use it\r
50                                 extend = this.extend || extend;\r
51                         }                       \r
52                         // copy each of the source object's properties to this object\r
53                         for (key in source) if (!Object.prototype[key]) {\r
54                                 extend.call(this, key, source[key]);\r
55                         }\r
56                 }\r
57                 return this;\r
58         },\r
59 \r
60         base: Base\r
61 };\r
62 \r
63 Base.extend = function(_instance, _static) { // subclass\r
64         var extend = Base.prototype.extend;\r
65         \r
66         // build the prototype\r
67         Base._prototyping = true;\r
68         var proto = new this;\r
69         extend.call(proto, _instance);\r
70         delete Base._prototyping;\r
71         \r
72         // create the wrapper for the constructor function\r
73         var constructor = proto.constructor;\r
74         var klass = proto.constructor = function() {\r
75                 if (!Base._prototyping) {\r
76                         if (this._constructing || this.constructor == klass) { // instantiation\r
77                                 this._constructing = true;\r
78                                 constructor.apply(this, arguments);\r
79                                 delete this._constructing;\r
80                         } else { // casting\r
81                                 var object = arguments[0];\r
82                                 if (object != null) {\r
83                                         (object.extend || extend).call(object, proto);\r
84                                 }\r
85                                 return object;\r
86                         }\r
87                 }\r
88         };\r
89         \r
90         // build the class interface\r
91         for (var i in Base) klass[i] = this[i];\r
92         klass.ancestor = this;\r
93         klass.base = Base.base;\r
94         klass.prototype = proto;\r
95         klass.toString = this.toString;\r
96         extend.call(klass, _static);\r
97         // class initialisation\r
98         if (typeof klass.init == "function") klass.init();\r
99         return klass;\r
100 };\r
101 \r
102 // initialise\r
103 Base = Base.extend({\r
104         constructor: function() {\r
105                 this.extend(arguments[0]);\r
106         }\r
107 }, {\r
108         ancestor: Object,\r
109         base: Base,\r
110         \r
111         implement: function(_interface) {\r
112                 if (typeof _interface == "function") {\r
113                         // if it's a function, call it\r
114                         _interface(this.prototype);\r
115                 } else {\r
116                         // add the interface using the extend() method\r
117                         this.prototype.extend(_interface);\r
118                 }\r
119                 return this;\r
120         }\r
121 });\r
122 \r
123 // =========================================================================\r
124 // lang/main.js\r
125 // =========================================================================\r
126 \r
127 var Legacy = typeof $Legacy == "undefined" ? {} : $Legacy;\r
128 \r
129 var K = function(k) {return k};\r
130 \r
131 var assert = function(condition, message, Err) {\r
132         if (!condition) {\r
133                 throw new (Err || Error)(message || "Assertion failed.");\r
134         }\r
135 };\r
136 \r
137 var assertType = function(object, type, message) {\r
138         if (type) {\r
139                 var condition = typeof type == "function" ? instanceOf(object, type) : typeof object == type;\r
140                 assert(condition, message || "Invalid type.", TypeError);\r
141         }\r
142 };\r
143 \r
144 var copy = function(object) {\r
145         var fn = new Function;\r
146         fn.prototype = object;\r
147         return new fn;\r
148 };\r
149 \r
150 var format = function(string) {\r
151         // replace %n with arguments[n]\r
152         // e.g. format("%1 %2%3 %2a %1%3", "she", "se", "lls");\r
153         // ==> "she sells sea shells"\r
154         // only supports nine replacements: %1 - %9\r
155         var args = arguments;\r
156         return String(string).replace(/%([1-9])/g, function(match, index) {\r
157                 return index < args.length ? args[index] : match;\r
158         });\r
159 };\r
160 \r
161 var $instanceOf = Legacy.instanceOf || new Function("o,k", "return o instanceof k");\r
162 var instanceOf = function(object, klass) {\r
163         assertType(klass, "function", "Invalid 'instanceOf' operand.");\r
164         if ($instanceOf(object, klass)) return true;\r
165         // handle exceptions where the target object originates from another frame\r
166         //  this is handy for JSON parsing (amongst other things)\r
167         if (object != null) switch (klass) {\r
168                 case Object:\r
169                         return true;\r
170                 case Number:\r
171                 case Boolean:\r
172                 case Function:\r
173                 case String:\r
174                         return typeof object == typeof klass.prototype.valueOf();\r
175                 case Array:\r
176                         // this is the only troublesome one\r
177                         return !!(object.join && object.splice && !arguments.callee(object, Function));\r
178                 case Date:\r
179                         return !!object.getTimezoneOffset;\r
180                 case RegExp:\r
181                         return String(object.constructor.prototype) == String(new RegExp);\r
182         }\r
183         return false;\r
184 };\r
185         \r
186 var match = function(string, expression) {\r
187         // same as String.match() except that this function will return an empty \r
188         // array if there is no match\r
189         return String(string).match(expression) || [];\r
190 };\r
191 \r
192 var RESCAPE = /([\/()[\]{}|*+-.,^$?\\])/g;\r
193 var rescape = function(string) {\r
194         // make a string safe for creating a RegExp\r
195         return String(string).replace(RESCAPE, "\\$1");\r
196 };\r
197 \r
198 var $slice = Array.prototype.slice;\r
199 var slice = function(object) {\r
200         // slice an array-like object\r
201         return $slice.apply(object, $slice.call(arguments, 1));\r
202 };\r
203 \r
204 var TRIM = /^\s+|\s+$/g;\r
205 var trim = function(string) {\r
206         return String(string).replace(TRIM, "");        \r
207 };\r
208 \r
209 // =========================================================================\r
210 // lang/extend.js\r
211 // =========================================================================\r
212 \r
213 var base = function(object, args) {\r
214         // invoke the base method with all supplied arguments\r
215         return object.base.apply(object, args);\r
216 };\r
217 \r
218 var extend = function(object) {\r
219         assert(object != Object.prototype, "Object.prototype is verboten!");\r
220         return Base.prototype.extend.apply(object, slice(arguments, 1));\r
221 };\r
222 \r
223 // =========================================================================\r
224 // lang/assignID.js\r
225 // =========================================================================\r
226 \r
227 var $ID = 1;\r
228 var assignID = function(object) {\r
229         // assign a unique id\r
230         if (!object.base2ID) object.base2ID = "b2_" + $ID++;\r
231         return object.base2ID;\r
232 };\r
233 \r
234 // =========================================================================\r
235 // lang/forEach.js\r
236 // =========================================================================\r
237 \r
238 if (typeof StopIteration == "undefined") {\r
239         StopIteration = new Error("StopIteration");\r
240 }\r
241 \r
242 var forEach = function(object, block, context) {\r
243         if (object == null) return;\r
244         if (typeof object == "function") {\r
245                 // functions are a special case\r
246                 var fn = Function;\r
247         } else if (typeof object.forEach == "function" && object.forEach != arguments.callee) {\r
248                 // the object implements a custom forEach method\r
249                 object.forEach(block, context);\r
250                 return;\r
251         } else if (typeof object.length == "number") {\r
252                 // the object is array-like\r
253                 forEach.Array(object, block, context);\r
254                 return;\r
255         }\r
256         forEach.Function(fn || Object, object, block, context);\r
257 };\r
258 \r
259 // these are the two core enumeration methods. all other forEach methods\r
260 //  eventually call one of these two.\r
261 \r
262 forEach.Array = function(array, block, context) {\r
263         var i, length = array.length; // preserve\r
264         if (typeof array == "string") {\r
265                 for (i = 0; i < length; i++) {\r
266                         block.call(context, array.charAt(i), i, array);\r
267                 }\r
268         } else {\r
269                 for (i = 0; i < length; i++) {\r
270                         block.call(context, array[i], i, array);\r
271                 }\r
272         }\r
273 };\r
274 \r
275 forEach.Function = Legacy.forEach || function(fn, object, block, context) {\r
276         // enumerate an object and compare its keys with fn's prototype\r
277         for (var key in object) {\r
278                 if (fn.prototype[key] === undefined) {\r
279                         block.call(context, object[key], key, object);\r
280                 }\r
281         }\r
282 };\r
283 \r
284 // =========================================================================\r
285 // base2/Base/forEach.js\r
286 // =========================================================================\r
287 \r
288 Base.forEach = function(object, block, context) {\r
289         forEach.Function(this, object, block, context);\r
290 };\r
291 \r
292 // =========================================================================\r
293 // base2/../Function.js\r
294 // =========================================================================\r
295 \r
296 // some browsers don't define this\r
297 \r
298 Function.prototype.prototype = {};\r
299 \r
300 \r
301 // =========================================================================\r
302 // base2/../String.js\r
303 // =========================================================================\r
304 \r
305 // fix String.replace (Safari/IE5.0)\r
306 \r
307 if ("".replace(/^/, String)) {\r
308         extend(String.prototype, "replace", function(expression, replacement) {\r
309                 if (typeof replacement == "function") { // Safari doesn't like functions\r
310                         if (instanceOf(expression, RegExp)) {\r
311                                 var regexp = expression;\r
312                                 var global = regexp.global;\r
313                                 if (global == null) global = /(g|gi)$/.test(regexp);\r
314                                 // we have to convert global RexpExps for exec() to work consistently\r
315                                 if (global) regexp = new RegExp(regexp.source); // non-global\r
316                         } else {\r
317                                 regexp = new RegExp(rescape(expression));\r
318                         }\r
319                         var match, string = this, result = "";\r
320                         while (string && (match = regexp.exec(string))) {\r
321                                 result += string.slice(0, match.index) + replacement.apply(this, match);\r
322                                 string = string.slice(match.index + match[0].length);\r
323                                 if (!global) break;\r
324                         }\r
325                         return result + string;\r
326                 } else {\r
327                         return base(this, arguments);\r
328                 }\r
329         });\r
330 }\r
331 \r
332 // =========================================================================\r
333 // base2/Abstract.js\r
334 // =========================================================================\r
335 \r
336 var Abstract = Base.extend({\r
337         constructor: function() {\r
338                 throw new TypeError("Class cannot be instantiated.");\r
339         }\r
340 });\r
341 \r
342 // =========================================================================\r
343 // base2/Module.js\r
344 // =========================================================================\r
345 \r
346 // based on ruby's Module class and Mozilla's Array generics:\r
347 //   http://www.ruby-doc.org/core/classes/Module.html\r
348 //   http://developer.mozilla.org/en/docs/New_in_JavaScript_1.6#Array_and_String_generics\r
349 \r
350 // A Module is used as the basis for creating interfaces that can be\r
351 // applied to other classes. *All* properties and methods are static.\r
352 // When a module is used as a mixin, methods defined on what would normally be\r
353 // the instance interface become instance methods of the target object.\r
354 \r
355 // Modules cannot be instantiated. Static properties and methods are inherited.\r
356 \r
357 var Module = Abstract.extend(null, {\r
358         extend: function(_interface, _static) {\r
359                 // extend a module to create a new module\r
360                 var module = this.base();\r
361                 // inherit static methods\r
362                 forEach (this, function(property, name) {\r
363                         if (!Module[name] && name != "init") {\r
364                                 extend(module, name, property);\r
365                         }\r
366                 });\r
367                 // implement module (instance AND static) methods\r
368                 module.implement(_interface);\r
369                 // implement static properties and methods\r
370                 extend(module, _static);\r
371                 // Make the submarine noises Larry!\r
372                 if (typeof module.init == "function") module.init();\r
373                 return module;\r
374         },\r
375         \r
376         implement: function(_interface) {\r
377                 // implement an interface on BOTH the instance and static interfaces\r
378                 var module = this;\r
379                 if (typeof _interface == "function") {\r
380                         module.base(_interface);\r
381                         forEach (_interface, function(property, name) {\r
382                                 if (!Module[name] && name != "init") {\r
383                                         extend(module, name, property);\r
384                                 }\r
385                         });\r
386                 } else {\r
387                         // create the instance interface\r
388                         Base.forEach (extend({}, _interface), function(property, name) {\r
389                                 // instance methods call the equivalent static method\r
390                                 if (typeof property == "function") {\r
391                                         property = function() {\r
392                                                 base; // force inheritance\r
393                                                 return module[name].apply(module, [this].concat(slice(arguments)));\r
394                                         };\r
395                                 }\r
396                                 if (!Module[name]) extend(this, name, property);\r
397                         }, module.prototype);\r
398                         // add the static interface\r
399                         extend(module, _interface);\r
400                 }\r
401                 return module;\r
402         }\r
403 });\r
404 \r
405 \r
406 // =========================================================================\r
407 // base2/Enumerable.js\r
408 // =========================================================================\r
409 \r
410 var Enumerable = Module.extend({\r
411         every: function(object, test, context) {\r
412                 var result = true;\r
413                 try {\r
414                         this.forEach (object, function(value, key) {\r
415                                 result = test.call(context, value, key, object);\r
416                                 if (!result) throw StopIteration;\r
417                         });\r
418                 } catch (error) {\r
419                         if (error != StopIteration) throw error;\r
420                 }\r
421                 return !!result; // cast to boolean\r
422         },\r
423         \r
424         filter: function(object, test, context) {\r
425                 return this.reduce(object, function(result, value, key) {\r
426                         if (test.call(context, value, key, object)) {\r
427                                 result[result.length] = value;\r
428                         }\r
429                         return result;\r
430                 }, new Array2);\r
431         },\r
432 \r
433         invoke: function(object, method) {\r
434                 // apply a method to each item in the enumerated object\r
435                 var args = slice(arguments, 2);\r
436                 return this.map(object, (typeof method == "function") ? function(item) {\r
437                         if (item != null) return method.apply(item, args);\r
438                 } : function(item) {\r
439                         if (item != null) return item[method].apply(item, args);\r
440                 });\r
441         },\r
442         \r
443         map: function(object, block, context) {\r
444                 var result = new Array2;\r
445                 this.forEach (object, function(value, key) {\r
446                         result[result.length] = block.call(context, value, key, object);\r
447                 });\r
448                 return result;\r
449         },\r
450         \r
451         pluck: function(object, key) {\r
452                 return this.map(object, function(item) {\r
453                         if (item != null) return item[key];\r
454                 });\r
455         },\r
456         \r
457         reduce: function(object, block, result, context) {\r
458                 this.forEach (object, function(value, key) {\r
459                         result = block.call(context, result, value, key, object);\r
460                 });\r
461                 return result;\r
462         },\r
463         \r
464         some: function(object, test, context) {\r
465                 return !this.every(object, function(value, key) {\r
466                         return !test.call(context, value, key, object);\r
467                 });\r
468         }\r
469 }, {\r
470         forEach: forEach\r
471 });\r
472 \r
473 // =========================================================================\r
474 // base2/Array2.js\r
475 // =========================================================================\r
476 \r
477 // The IArray module implements all Array methods.\r
478 // This module is not public but its methods are accessible through the Array2 object (below). \r
479 \r
480 var IArray = Module.extend({\r
481         combine: function(keys, values) {\r
482                 // combine two arrays to make a hash\r
483                 if (!values) values = keys;\r
484                 return this.reduce(keys, function(object, key, index) {\r
485                         object[key] = values[index];\r
486                         return object;\r
487                 }, {});\r
488         },\r
489         \r
490         copy: function(array) {\r
491                 return this.concat(array);\r
492         },\r
493         \r
494         contains: function(array, item) {\r
495                 return this.indexOf(array, item) != -1;\r
496         },\r
497         \r
498         forEach: forEach.Array,\r
499         \r
500         indexOf: function(array, item, fromIndex) {\r
501                 var length = array.length;\r
502                 if (fromIndex == null) {\r
503                         fromIndex = 0;\r
504                 } else if (fromIndex < 0) {\r
505                         fromIndex = Math.max(0, length + fromIndex);\r
506                 }\r
507                 for (var i = fromIndex; i < length; i++) {\r
508                         if (array[i] === item) return i;\r
509                 }\r
510                 return -1;\r
511         },\r
512         \r
513         insertAt: function(array, item, index) {\r
514                 this.splice(array, index, 0, item);\r
515                 return item;\r
516         },\r
517         \r
518         insertBefore: function(array, item, before) {\r
519                 var index = this.indexOf(array, before);\r
520                 if (index == -1) this.push(array, item);\r
521                 else this.splice(array, index, 0, item);\r
522                 return item;\r
523         },\r
524         \r
525         lastIndexOf: function(array, item, fromIndex) {\r
526                 var length = array.length;\r
527                 if (fromIndex == null) {\r
528                         fromIndex = length - 1;\r
529                 } else if (from < 0) {\r
530                         fromIndex = Math.max(0, length + fromIndex);\r
531                 }\r
532                 for (var i = fromIndex; i >= 0; i--) {\r
533                         if (array[i] === item) return i;\r
534                 }\r
535                 return -1;\r
536         },\r
537         \r
538         remove: function(array, item) {\r
539                 var index = this.indexOf(array, item);\r
540                 if (index != -1) this.removeAt(array, index);\r
541                 return item;\r
542         },\r
543         \r
544         removeAt: function(array, index) {\r
545                 var item = array[index];\r
546                 this.splice(array, index, 1);\r
547                 return item;\r
548         }\r
549 });\r
550 \r
551 IArray.prototype.forEach = function(block, context) {\r
552         forEach.Array(this, block, context);\r
553 };\r
554 \r
555 IArray.implement(Enumerable);\r
556 \r
557 forEach ("concat,join,pop,push,reverse,shift,slice,sort,splice,unshift".split(","), function(name) {\r
558         IArray[name] = function(array) {\r
559                 return Array.prototype[name].apply(array, slice(arguments, 1));\r
560         };\r
561 });\r
562 \r
563 // create a faux constructor that augments the built-in Array object\r
564 var Array2 = function() {\r
565         return IArray(this.constructor == IArray ? Array.apply(null, arguments) : arguments[0]);\r
566 };\r
567 // expose IArray.prototype so that it can be extended\r
568 Array2.prototype = IArray.prototype;\r
569 \r
570 forEach (IArray, function(method, name, proto) {\r
571         if (Array[name]) {\r
572                 IArray[name] = Array[name];\r
573                 delete IArray.prototype[name];\r
574         }\r
575         Array2[name] = IArray[name];\r
576 });\r
577 \r
578 // =========================================================================\r
579 // base2/Hash.js\r
580 // =========================================================================\r
581 \r
582 var HASH = "#" + Number(new Date);\r
583 var KEYS = HASH + "keys";\r
584 var VALUES = HASH + "values";\r
585 \r
586 var Hash = Base.extend({\r
587         constructor: function(values) {\r
588                 this[KEYS] = new Array2;\r
589                 this[VALUES] = {};\r
590                 this.merge(values);\r
591         },\r
592 \r
593         copy: function() {\r
594                 var copy = new this.constructor(this);\r
595                 Base.forEach (this, function(property, name) {\r
596                         if (typeof property != "function" && name.charAt(0) != "#") {\r
597                                 copy[name] = property;\r
598                         }\r
599                 });\r
600                 return copy;\r
601         },\r
602 \r
603         // ancient browsers throw an error when we use "in" as an operator \r
604         //  so we must create the function dynamically\r
605         exists: Legacy.exists || new Function("k", format("return('%1'+k)in this['%2']", HASH, VALUES)),\r
606 \r
607         fetch: function(key) {\r
608                 return this[VALUES][HASH + key];\r
609         },\r
610 \r
611         forEach: function(block, context) {\r
612                 forEach (this[KEYS], function(key) {\r
613                         block.call(context, this.fetch(key), key, this);\r
614                 }, this);\r
615         },\r
616 \r
617         keys: function(index, length) {\r
618                 var keys = this[KEYS] || new Array2;\r
619                 switch (arguments.length) {\r
620                         case 0: return keys.copy();\r
621                         case 1: return keys[index];\r
622                         default: return keys.slice(index, length);\r
623                 }\r
624         },\r
625 \r
626         merge: function(values) {\r
627                 forEach (arguments, function(values) {\r
628                         forEach (values, function(value, key) {\r
629                                 this.store(key, value);\r
630                         }, this);\r
631                 }, this);\r
632                 return this;\r
633         },\r
634 \r
635         remove: function(key) {\r
636                 var value = this.fetch(key);\r
637                 this[KEYS].remove(String(key));\r
638                 delete this[VALUES][HASH + key];\r
639                 return value;\r
640         },\r
641 \r
642         store: function(key, value) {\r
643                 if (arguments.length == 1) value = key;\r
644                 // only store the key for a new entry\r
645                 if (!this.exists(key)) {\r
646                         this[KEYS].push(String(key));\r
647                 }\r
648                 // create the new entry (or overwrite the old entry)\r
649                 this[VALUES][HASH + key] = value;\r
650                 return value;\r
651         },\r
652 \r
653         toString: function() {\r
654                 return String(this[KEYS]);\r
655         },\r
656 \r
657         union: function(values) {\r
658                 return this.merge.apply(this.copy(), arguments);\r
659         },\r
660 \r
661         values: function(index, length) {\r
662                 var values = this.map(K);\r
663                 switch (arguments.length) {\r
664                         case 0: return values;\r
665                         case 1: return values[index];\r
666                         default: return values.slice(index, length);\r
667                 }\r
668         }\r
669 });\r
670 \r
671 Hash.implement(Enumerable);\r
672 \r
673 // =========================================================================\r
674 // base2/Collection.js\r
675 // =========================================================================\r
676 \r
677 // A Hash that is more array-like (accessible by index).\r
678 \r
679 // Collection classes have a special (optional) property: Item\r
680 // The Item property points to a constructor function.\r
681 // Members of the collection must be an instance of Item.\r
682 // e.g.\r
683 //     var Dates = Collection.extend();                 // create a collection class\r
684 //     Dates.Item = Date;                               // only JavaScript Date objects allowed as members\r
685 //     var appointments = new Dates();                  // instantiate the class\r
686 //     appointments.add(appointmentId, new Date);       // add a date\r
687 //     appointments.add(appointmentId, "tomorrow");     // ERROR!\r
688 \r
689 // The static create() method is responsible for all construction of collection items.\r
690 // Instance methods that add new items (add, store, insertAt, replaceAt) pass *all* of their arguments\r
691 // to the static create() method. If you want to modify the way collection items are \r
692 // created then you only need to override this method for custom collections.\r
693 \r
694 var Collection = Hash.extend({\r
695         add: function(key, item) {\r
696                 // Duplicates not allowed using add().\r
697                 //  - but you can still overwrite entries using store()\r
698                 assert(!this.exists(key), "Duplicate key.");\r
699                 return this.store.apply(this, arguments);\r
700         },\r
701 \r
702         count: function() {\r
703                 return this[KEYS].length;\r
704         },\r
705 \r
706         indexOf: function(key) {\r
707                 return this[KEYS].indexOf(String(key));\r
708         },\r
709 \r
710         insertAt: function(index, key, item) {\r
711                 assert(!this.exists(key), "Duplicate key.");\r
712                 this[KEYS].insertAt(index, String(key));\r
713                 return this.store.apply(this, slice(arguments, 1));\r
714         },\r
715 \r
716         item: function(index) {\r
717                 return this.fetch(this[KEYS][index]);\r
718         },\r
719 \r
720         removeAt: function(index) {\r
721                 return this.remove(this[KEYS][index]);\r
722         },\r
723 \r
724         reverse: function() {\r
725                 this[KEYS].reverse();\r
726                 return this;\r
727         },\r
728 \r
729         sort: function(compare) {\r
730                 if (compare) {\r
731                         var self = this;\r
732                         this[KEYS].sort(function(key1, key2) {\r
733                                 return compare(self.fetch(key1), self.fetch(key2), key1, key2);\r
734                         });\r
735                 } else this[KEYS].sort();\r
736                 return this;\r
737         },\r
738 \r
739         store: function(key, item) {\r
740                 if (arguments.length == 1) item = key;\r
741                 item = this.constructor.create.apply(this.constructor, arguments);\r
742                 return this.base(key, item);\r
743         },\r
744 \r
745         storeAt: function(index, item) {\r
746                 //-dean: get rid of this?\r
747                 assert(index < this.count(), "Index out of bounds.");\r
748                 arguments[0] = this[KEYS][index];\r
749                 return this.store.apply(this, arguments);\r
750         }\r
751 }, {\r
752         Item: null, // if specified, all members of the Collection must be instances of Item\r
753         \r
754         create: function(key, item) {\r
755                 if (this.Item && !instanceOf(item, this.Item)) {\r
756                         item = new this.Item(key, item);\r
757                 }\r
758                 return item;\r
759         },\r
760         \r
761         extend: function(_instance, _static) {\r
762                 var klass = this.base(_instance);\r
763                 klass.create = this.create;\r
764                 extend(klass, _static);\r
765                 if (!klass.Item) {\r
766                         klass.Item = this.Item;\r
767                 } else if (typeof klass.Item != "function") {\r
768                         klass.Item = (this.Item || Base).extend(klass.Item);\r
769                 }\r
770                 if (typeof klass.init == "function") klass.init();\r
771                 return klass;\r
772         }\r
773 });\r
774 \r
775 // =========================================================================\r
776 // base2/RegGrp.js\r
777 // =========================================================================\r
778 \r
779 var RegGrp = Collection.extend({\r
780         constructor: function(values, flags) {\r
781                 this.base(values);\r
782                 if (typeof flags == "string") {\r
783                         this.global = /g/.test(flags);\r
784                         this.ignoreCase = /i/.test(flags);\r
785                 }\r
786         },\r
787 \r
788         global: true, // global is the default setting\r
789         ignoreCase: false,\r
790 \r
791         exec: function(string, replacement) {\r
792                 if (arguments.length == 1) {\r
793                         var keys = this[KEYS];\r
794                         var values = this[VALUES];\r
795                         replacement = function(match) {\r
796                                 if (!match) return "";\r
797                                 var offset = 1, i = 0;\r
798                                 // loop through the values\r
799                                 while (match = values[HASH + keys[i++]]) {\r
800                                         // do we have a result?\r
801                                         if (arguments[offset]) {\r
802                                                 var replacement = match.replacement;\r
803                                                 switch (typeof replacement) {\r
804                                                         case "function":\r
805                                                                 return replacement.apply(null, slice(arguments, offset));\r
806                                                         case "number":\r
807                                                                 return arguments[offset + replacement];\r
808                                                         default:\r
809                                                                 return replacement;\r
810                                                 }\r
811                                         // no? then skip over references to sub-expressions\r
812                                         } else offset += match.length + 1;\r
813                                 }\r
814                         };\r
815                 }\r
816                 var flags = (this.global ? "g" : "") + (this.ignoreCase ? "i" : "");\r
817                 return String(string).replace(new RegExp(this, flags), replacement);\r
818         },\r
819 \r
820         test: function(string) {\r
821                 return this.exec(string) != string;\r
822         },\r
823         \r
824         toString: function() {\r
825                 var length = 0;\r
826                 return "(" + this.map(function(item) {\r
827                         // fix back references\r
828                         var expression = String(item).replace(/\\(\d+)/g, function($, index) {\r
829                                 return "\\" + (1 + Number(index) + length);\r
830                         });\r
831                         length += item.length + 1;\r
832                         return expression;\r
833                 }).join(")|(") + ")";\r
834         }\r
835 }, {\r
836         IGNORE: "$0",\r
837         \r
838         init: function() {\r
839                 forEach ("add,exists,fetch,remove,store".split(","), function(name) {\r
840                         extend(this, name, function(expression) {\r
841                                 if (instanceOf(expression, RegExp)) {\r
842                                         expression = expression.source;\r
843                                 }\r
844                                 return base(this, arguments);\r
845                         });\r
846                 }, this.prototype);\r
847         }\r
848 });\r
849 \r
850 // =========================================================================\r
851 // base2/RegGrp/Item.js\r
852 // =========================================================================\r
853 \r
854 RegGrp.Item = Base.extend({\r
855         constructor: function(expression, replacement) {\r
856                 var ESCAPE = /\\./g;\r
857                 var STRING = /(['"])\1\+(.*)\+\1\1$/;\r
858         \r
859                 expression = instanceOf(expression, RegExp) ? expression.source : String(expression);\r
860                 \r
861                 if (typeof replacement == "number") replacement = String(replacement);\r
862                 else if (replacement == null) replacement = "";\r
863                 \r
864                 // count the number of sub-expressions\r
865                 //  - add one because each pattern is itself a sub-expression\r
866                 this.length = match(expression.replace(ESCAPE, "").replace(/\[[^\]]+\]/g, ""), /\(/g).length;\r
867                 \r
868                 // does the pattern use sub-expressions?\r
869                 if (typeof replacement == "string" && /\$(\d+)/.test(replacement)) {\r
870                         // a simple lookup? (e.g. "$2")\r
871                         if (/^\$\d+$/.test(replacement)) {\r
872                                 // store the index (used for fast retrieval of matched strings)\r
873                                 replacement = parseInt(replacement.slice(1));\r
874                         } else { // a complicated lookup (e.g. "Hello $2 $1")\r
875                                 // build a function to do the lookup\r
876                                 var i = this.length + 1;\r
877                                 var Q = /'/.test(replacement.replace(ESCAPE, "")) ? '"' : "'";\r
878                                 replacement = replacement.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\$(\d+)/g, Q +\r
879                                         "+(arguments[$1]||" + Q+Q + ")+" + Q);\r
880                                 replacement = new Function("return " + Q + replacement.replace(STRING, "$1") + Q);\r
881                         }\r
882                 }\r
883                 this.replacement = replacement;\r
884                 this.toString = function() {\r
885                         return expression || "";\r
886                 };\r
887         },\r
888         \r
889         length: 0,\r
890         replacement: ""\r
891 });\r
892 \r
893 // =========================================================================\r
894 // base2/Namespace.js\r
895 // =========================================================================\r
896 \r
897 var Namespace = Base.extend({\r
898         constructor: function(_private, _public) {\r
899                 this.extend(_public);\r
900                 this.toString = function() {\r
901                         return format("[base2.%1]", this.name);\r
902                 };\r
903                 \r
904                 // initialise\r
905                 if (typeof this.init == "function") this.init();\r
906                 \r
907                 if (this.name != "base2") {\r
908                         this.namespace = format("var %1=base2.%1;", this.name);\r
909                 }\r
910                 \r
911                 var namespace = "var base=" + base + ";";\r
912                 var imports = ("base2,lang," + this.imports).split(",");\r
913                 _private.imports = Enumerable.reduce(imports, function(namespace, name) {\r
914                         if (base2[name]) namespace += base2[name].namespace;\r
915                         return namespace;\r
916                 }, namespace);\r
917                 \r
918                 var namespace = format("base2.%1=%1;", this.name);\r
919                 var exports = this.exports.split(",");\r
920                 _private.exports = Enumerable.reduce(exports, function(namespace, name) {\r
921                         if (name) {\r
922                                 this.namespace += format("var %2=%1.%2;", this.name, name);\r
923                                 namespace += format("if(!%1.%2)%1.%2=%2;base2.%2=%1.%2;", this.name, name);\r
924                         }\r
925                         return namespace;\r
926                 }, namespace, this);\r
927                 \r
928                 if (this.name != "base2") {\r
929                         base2.namespace += format("var %1=base2.%1;", this.name);\r
930                 }\r
931         },\r
932 \r
933         exports: "",\r
934         imports: "",\r
935         namespace: "",\r
936         name: ""\r
937 });\r
938 \r
939 base2 = new Namespace(this, {\r
940         name:    "base2",\r
941         version: "0.8 (alpha)",\r
942         exports: "Base,Abstract,Module,Enumerable,Array2,Hash,Collection,RegGrp,Namespace"\r
943 });\r
944 \r
945 base2.toString = function() {\r
946         return "[base2]";\r
947 };\r
948 \r
949 eval(this.exports);\r
950 \r
951 // =========================================================================\r
952 // base2/lang/namespace.js\r
953 // =========================================================================\r
954 \r
955 var lang = new Namespace(this, {\r
956         name:    "lang",\r
957         version: base2.version,\r
958         exports: "K,assert,assertType,assignID,copy,instanceOf,extend,format,forEach,match,rescape,slice,trim",\r
959         \r
960         init: function() {\r
961                 this.extend = extend;\r
962                 // add the Enumerable methods to the lang object\r
963                 forEach (Enumerable.prototype, function(method, name) {\r
964                         if (!Module[name]) {\r
965                                 this[name] = function() {\r
966                                         return Enumerable[name].apply(Enumerable, arguments);\r
967                                 };\r
968                                 this.exports += "," + name;\r
969                         }\r
970                 }, this);\r
971         }\r
972 });\r
973 \r
974 eval(this.exports);\r
975 \r
976 base2.namespace += lang.namespace;\r
977 \r
978 }; ////////////////////  END: CLOSURE  /////////////////////////////////////\r