Upgrade to ExtJS 4.0.7 - Released 10/19/2011
[extjs.git] / docs / source / Array2.html
index d007c7f..3765538 100644 (file)
@@ -3,8 +3,8 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   <title>The source code</title>
-  <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
-  <script type="text/javascript" src="../prettify/prettify.js"></script>
+  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
+  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   <style type="text/css">
     .highlight { display: block; background-color: #ddd; }
   </style>
   </script>
 </head>
 <body onload="prettyPrint(); highlight();">
-  <pre class="prettyprint lang-js"><span id='Ext-Array'>/**
-</span> * @author Jacky Nguyen &lt;jacky@sencha.com&gt;
- * @docauthor Jacky Nguyen &lt;jacky@sencha.com&gt;
- * @class Ext.Array
- *
- * A set of useful static methods to deal with arrays; provide missing methods for older browsers.
-
- * @singleton
- * @markdown
+  <pre class="prettyprint lang-js"><span id='Ext-data-reader-Array-method-constructor'><span id='Ext-data-reader-Array'>/**
+</span></span> * @author Ed Spencer
+ * @class Ext.data.reader.Array
+ * @extends Ext.data.reader.Json
+ * 
+ * &lt;p&gt;Data reader class to create an Array of {@link Ext.data.Model} objects from an Array.
+ * Each element of that Array represents a row of data fields. The
+ * fields are pulled into a Record object using as a subscript, the &lt;code&gt;mapping&lt;/code&gt; property
+ * of the field definition if it exists, or the field's ordinal position in the definition.&lt;/p&gt;
+ * 
+ * &lt;p&gt;&lt;u&gt;Example code:&lt;/u&gt;&lt;/p&gt;
+ * 
+&lt;pre&gt;&lt;code&gt;
+Employee = Ext.define('Employee', {
+    extend: 'Ext.data.Model',
+    fields: [
+        'id',
+        {name: 'name', mapping: 1},         // &quot;mapping&quot; only needed if an &quot;id&quot; field is present which
+        {name: 'occupation', mapping: 2}    // precludes using the ordinal position as the index.        
+    ]
+});
+
+var myReader = new Ext.data.reader.Array({
+    model: 'Employee'
+}, Employee);
+&lt;/code&gt;&lt;/pre&gt;
+ * 
+ * &lt;p&gt;This would consume an Array like this:&lt;/p&gt;
+ * 
+&lt;pre&gt;&lt;code&gt;
+[ [1, 'Bill', 'Gardener'], [2, 'Ben', 'Horticulturalist'] ]
+&lt;/code&gt;&lt;/pre&gt;
+ * 
+ * @constructor
+ * Create a new ArrayReader
+ * @param {Object} meta Metadata configuration options.
  */
-(function() {
-
-    var arrayPrototype = Array.prototype,
-        slice = arrayPrototype.slice,
-        supportsSplice = function () {
-            var array = [],
-                lengthBefore,
-                j = 20;
-
-            if (!array.splice) {
-                return false;
-            }
-
-            // This detects a bug in IE8 splice method:
-            // see http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/6e946d03-e09f-4b22-a4dd-cd5e276bf05a/
-
-            while (j--) {
-                array.push(&quot;A&quot;);
-            }
-
-            array.splice(15, 0, &quot;F&quot;, &quot;F&quot;, &quot;F&quot;, &quot;F&quot;, &quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;,&quot;F&quot;);
-
-            lengthBefore = array.length; //41
-            array.splice(13, 0, &quot;XXX&quot;); // add one element
-
-            if (lengthBefore+1 != array.length) {
-                return false;
-            }
-            // end IE8 bug
-
-            return true;
-        }(),
-        supportsForEach = 'forEach' in arrayPrototype,
-        supportsMap = 'map' in arrayPrototype,
-        supportsIndexOf = 'indexOf' in arrayPrototype,
-        supportsEvery = 'every' in arrayPrototype,
-        supportsSome = 'some' in arrayPrototype,
-        supportsFilter = 'filter' in arrayPrototype,
-        supportsSort = function() {
-            var a = [1,2,3,4,5].sort(function(){ return 0; });
-            return a[0] === 1 &amp;&amp; a[1] === 2 &amp;&amp; a[2] === 3 &amp;&amp; a[3] === 4 &amp;&amp; a[4] === 5;
-        }(),
-        supportsSliceOnNodeList = true,
-        ExtArray;
-
-    try {
-        // IE 6 - 8 will throw an error when using Array.prototype.slice on NodeList
-        if (typeof document !== 'undefined') {
-            slice.call(document.getElementsByTagName('body'));
-        }
-    } catch (e) {
-        supportsSliceOnNodeList = false;
-    }
-
-    function fixArrayIndex (array, index) {
-        return (index &lt; 0) ? Math.max(0, array.length + index)
-                           : Math.min(array.length, index);
-    }
-
-    /*
-    Does the same work as splice, but with a slightly more convenient signature. The splice
-    method has bugs in IE8, so this is the implementation we use on that platform.
-
-    The rippling of items in the array can be tricky. Consider two use cases:
-
-                  index=2
-                  removeCount=2
-                 /=====\
-        +---+---+---+---+---+---+---+---+
-        | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
-        +---+---+---+---+---+---+---+---+
-                         /  \/  \/  \/  \
-                        /   /\  /\  /\   \
-                       /   /  \/  \/  \   +--------------------------+
-                      /   /   /\  /\   +--------------------------+   \
-                     /   /   /  \/  +--------------------------+   \   \
-                    /   /   /   /+--------------------------+   \   \   \
-                   /   /   /   /                             \   \   \   \
-                  v   v   v   v                               v   v   v   v
-        +---+---+---+---+---+---+       +---+---+---+---+---+---+---+---+---+
-        | 0 | 1 | 4 | 5 | 6 | 7 |       | 0 | 1 | a | b | c | 4 | 5 | 6 | 7 |
-        +---+---+---+---+---+---+       +---+---+---+---+---+---+---+---+---+
-        A                               B        \=========/
-                                                 insert=[a,b,c]
-
-    In case A, it is obvious that copying of [4,5,6,7] must be left-to-right so
-    that we don't end up with [0,1,6,7,6,7]. In case B, we have the opposite; we
-    must go right-to-left or else we would end up with [0,1,a,b,c,4,4,4,4].
-    */
-    function replaceSim (array, index, removeCount, insert) {
-        var add = insert ? insert.length : 0,
-            length = array.length,
-            pos = fixArrayIndex(array, index);
-
-        // we try to use Array.push when we can for efficiency...
-        if (pos === length) {
-            if (add) {
-                array.push.apply(array, insert);
-            }
-        } else {
-            var remove = Math.min(removeCount, length - pos),
-                tailOldPos = pos + remove,
-                tailNewPos = tailOldPos + add - remove,
-                tailCount = length - tailOldPos,
-                lengthAfterRemove = length - remove,
-                i;
-
-            if (tailNewPos &lt; tailOldPos) { // case A
-                for (i = 0; i &lt; tailCount; ++i) {
-                    array[tailNewPos+i] = array[tailOldPos+i];
-                }
-            } else if (tailNewPos &gt; tailOldPos) { // case B
-                for (i = tailCount; i--; ) {
-                    array[tailNewPos+i] = array[tailOldPos+i];
-                }
-            } // else, add == remove (nothing to do)
-
-            if (add &amp;&amp; pos === lengthAfterRemove) {
-                array.length = lengthAfterRemove; // truncate array
-                array.push.apply(array, insert);
-            } else {
-                array.length = lengthAfterRemove + add; // reserves space
-                for (i = 0; i &lt; add; ++i) {
-                    array[pos+i] = insert[i];
-                }
-            }
-        }
-
-        return array;
-    }
-
-    function replaceNative (array, index, removeCount, insert) {
-        if (insert &amp;&amp; insert.length) {
-            if (index &lt; array.length) {
-                array.splice.apply(array, [index, removeCount].concat(insert));
-            } else {
-                array.push.apply(array, insert);
-            }
-        } else {
-            array.splice(index, removeCount);
-        }
-        return array;
-    }
-
-    function eraseSim (array, index, removeCount) {
-        return replaceSim(array, index, removeCount);
-    }
-
-    function eraseNative (array, index, removeCount) {
-        array.splice(index, removeCount);
-        return array;
-    }
-
-    function spliceSim (array, index, removeCount) {
-        var pos = fixArrayIndex(array, index),
-            removed = array.slice(index, fixArrayIndex(array, pos+removeCount));
-
-        if (arguments.length &lt; 4) {
-            replaceSim(array, pos, removeCount);
-        } else {
-            replaceSim(array, pos, removeCount, slice.call(arguments, 3));
+Ext.define('Ext.data.reader.Array', {
+    extend: 'Ext.data.reader.Json',
+    alternateClassName: 'Ext.data.ArrayReader',
+    alias : 'reader.array',
+
+<span id='Ext-data-reader-Array-method-buildExtractors'>    /**
+</span>     * @private
+     * Most of the work is done for us by JsonReader, but we need to overwrite the field accessors to just
+     * reference the correct position in the array.
+     */
+    buildExtractors: function() {
+        this.callParent(arguments);
+        
+        var fields = this.model.prototype.fields.items,
+            i = 0,
+            length = fields.length,
+            extractorFunctions = [],
+            map;
+        
+        for (; i &lt; length; i++) {
+            map = fields[i].mapping;
+            extractorFunctions.push(function(index) {
+                return function(data) {
+                    return data[index];
+                };
+            }(map !== null ? map : i));
         }
-
-        return removed;
-    }
-
-    function spliceNative (array) {
-        return array.splice.apply(array, slice.call(arguments, 1));
+        
+        this.extractorFunctions = extractorFunctions;
     }
-
-    var erase = supportsSplice ? eraseNative : eraseSim,
-        replace = supportsSplice ? replaceNative : replaceSim,
-        splice = supportsSplice ? spliceNative : spliceSim;
-
-    // NOTE: from here on, use erase, replace or splice (not native methods)...
-
-    ExtArray = Ext.Array = {
-<span id='Ext-Array-method-each'>        /**
-</span>         * Iterates an array or an iterable value and invoke the given callback function for each item.
-         *
-         *     var countries = ['Vietnam', 'Singapore', 'United States', 'Russia'];
-         *
-         *     Ext.Array.each(countries, function(name, index, countriesItSelf) {
-         *         console.log(name);
-         *     });
-         *
-         *     var sum = function() {
-         *         var sum = 0;
-         *
-         *         Ext.Array.each(arguments, function(value) {
-         *             sum += value;
-         *         });
-         *
-         *         return sum;
-         *     };
-         *
-         *     sum(1, 2, 3); // returns 6
-         *
-         * The iteration can be stopped by returning false in the function callback.
-         *
-         *     Ext.Array.each(countries, function(name, index, countriesItSelf) {
-         *         if (name === 'Singapore') {
-         *             return false; // break here
-         *         }
-         *     });
-         *
-         * {@link Ext#each Ext.each} is alias for {@link Ext.Array#each Ext.Array.each}
-         *
-         * @param {Array/NodeList/Mixed} iterable The value to be iterated. If this
-         * argument is not iterable, the callback function is called once.
-         * @param {Function} fn The callback function. If it returns false, the iteration stops and this method returns
-         * the current `index`. Arguments passed to this callback function are:
-         *
-         * - `item` : Mixed - The item at the current `index` in the passed `array`
-         * - `index` : Number - The current `index` within the `array`
-         * - `allItems` : Array/NodeList/Mixed - The `array` passed as the first argument to `Ext.Array.each`
-         *
-         * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
-         * @param {Boolean} reverse (Optional) Reverse the iteration order (loop from the end to the beginning)
-         * Defaults false
-         * @return {Boolean} See description for the `fn` parameter.
-         */
-        each: function(array, fn, scope, reverse) {
-            array = ExtArray.from(array);
-
-            var i,
-                ln = array.length;
-
-            if (reverse !== true) {
-                for (i = 0; i &lt; ln; i++) {
-                    if (fn.call(scope || array[i], array[i], i, array) === false) {
-                        return i;
-                    }
-                }
-            }
-            else {
-                for (i = ln - 1; i &gt; -1; i--) {
-                    if (fn.call(scope || array[i], array[i], i, array) === false) {
-                        return i;
-                    }
-                }
-            }
-
-            return true;
-        },
-
-<span id='Ext-Array-method-forEach'>        /**
-</span>         * Iterates an array and invoke the given callback function for each item. Note that this will simply
-         * delegate to the native Array.prototype.forEach method if supported.
-         * It doesn't support stopping the iteration by returning false in the callback function like
-         * {@link Ext.Array#each}. However, performance could be much better in modern browsers comparing with
-         * {@link Ext.Array#each}
-         *
-         * @param {Array} array The array to iterate
-         * @param {Function} fn The function callback, to be invoked these arguments:
-         *
-         * - `item` : Mixed - The item at the current `index` in the passed `array`
-         * - `index` : Number - The current `index` within the `array`
-         * - `allItems` : Array - The `array` itself which was passed as the first argument
-         *
-         * @param {Object} scope (Optional) The execution scope (`this`) in which the specified function is executed.
-         */
-        forEach: function(array, fn, scope) {
-            if (supportsForEach) {
-                return array.forEach(fn, scope);
-            }
-
-            var i = 0,
-                ln = array.length;
-
-            for (; i &lt; ln; i++) {
-                fn.call(scope, array[i], i, array);
-            }
-        },
-
-<span id='Ext-Array-method-indexOf'>        /**
-</span>         * Get the index of the provided `item` in the given `array`, a supplement for the
-         * missing arrayPrototype.indexOf in Internet Explorer.
-         *
-         * @param {Array} array The array to check
-         * @param {Mixed} item The item to look for
-         * @param {Number} from (Optional) The index at which to begin the search
-         * @return {Number} The index of item in the array (or -1 if it is not found)
-         */
-        indexOf: function(array, item, from) {
-            if (supportsIndexOf) {
-                return array.indexOf(item, from);
-            }
-
-            var i, length = array.length;
-
-            for (i = (from &lt; 0) ? Math.max(0, length + from) : from || 0; i &lt; length; i++) {
-                if (array[i] === item) {
-                    return i;
-                }
-            }
-
-            return -1;
-        },
-
-<span id='Ext-Array-method-contains'>        /**
-</span>         * Checks whether or not the given `array` contains the specified `item`
-         *
-         * @param {Array} array The array to check
-         * @param {Mixed} item The item to look for
-         * @return {Boolean} True if the array contains the item, false otherwise
-         */
-        contains: function(array, item) {
-            if (supportsIndexOf) {
-                return array.indexOf(item) !== -1;
-            }
-
-            var i, ln;
-
-            for (i = 0, ln = array.length; i &lt; ln; i++) {
-                if (array[i] === item) {
-                    return true;
-                }
-            }
-
-            return false;
-        },
-
-<span id='Ext-Array-method-toArray'>        /**
-</span>         * Converts any iterable (numeric indices and a length property) into a true array.
-         *
-         *     function test() {
-         *         var args = Ext.Array.toArray(arguments),
-         *             fromSecondToLastArgs = Ext.Array.toArray(arguments, 1);
-         *
-         *         alert(args.join(' '));
-         *         alert(fromSecondToLastArgs.join(' '));
-         *     }
-         *
-         *     test('just', 'testing', 'here'); // alerts 'just testing here';
-         *                                      // alerts 'testing here';
-         *
-         *     Ext.Array.toArray(document.getElementsByTagName('div')); // will convert the NodeList into an array
-         *     Ext.Array.toArray('splitted'); // returns ['s', 'p', 'l', 'i', 't', 't', 'e', 'd']
-         *     Ext.Array.toArray('splitted', 0, 3); // returns ['s', 'p', 'l', 'i']
-         *
-         * {@link Ext#toArray Ext.toArray} is alias for {@link Ext.Array#toArray Ext.Array.toArray}
-         *
-         * @param {Mixed} iterable the iterable object to be turned into a true Array.
-         * @param {Number} start (Optional) a zero-based index that specifies the start of extraction. Defaults to 0
-         * @param {Number} end (Optional) a zero-based index that specifies the end of extraction. Defaults to the last
-         * index of the iterable value
-         * @return {Array} array
-         */
-        toArray: function(iterable, start, end){
-            if (!iterable || !iterable.length) {
-                return [];
-            }
-
-            if (typeof iterable === 'string') {
-                iterable = iterable.split('');
-            }
-
-            if (supportsSliceOnNodeList) {
-                return slice.call(iterable, start || 0, end || iterable.length);
-            }
-
-            var array = [],
-                i;
-
-            start = start || 0;
-            end = end ? ((end &lt; 0) ? iterable.length + end : end) : iterable.length;
-
-            for (i = start; i &lt; end; i++) {
-                array.push(iterable[i]);
-            }
-
-            return array;
-        },
-
-<span id='Ext-Array-method-pluck'>        /**
-</span>         * Plucks the value of a property from each item in the Array. Example:
-         *
-         *     Ext.Array.pluck(Ext.query(&quot;p&quot;), &quot;className&quot;); // [el1.className, el2.className, ..., elN.className]
-         *
-         * @param {Array|NodeList} array The Array of items to pluck the value from.
-         * @param {String} propertyName The property name to pluck from each element.
-         * @return {Array} The value from each item in the Array.
-         */
-        pluck: function(array, propertyName) {
-            var ret = [],
-                i, ln, item;
-
-            for (i = 0, ln = array.length; i &lt; ln; i++) {
-                item = array[i];
-
-                ret.push(item[propertyName]);
-            }
-
-            return ret;
-        },
-
-<span id='Ext-Array-method-map'>        /**
-</span>         * Creates a new array with the results of calling a provided function on every element in this array.
-         *
-         * @param {Array} array
-         * @param {Function} fn Callback function for each item
-         * @param {Object} scope Callback function scope
-         * @return {Array} results
-         */
-        map: function(array, fn, scope) {
-            if (supportsMap) {
-                return array.map(fn, scope);
-            }
-
-            var results = [],
-                i = 0,
-                len = array.length;
-
-            for (; i &lt; len; i++) {
-                results[i] = fn.call(scope, array[i], i, array);
-            }
-
-            return results;
-        },
-
-<span id='Ext-Array-method-every'>        /**
-</span>         * Executes the specified function for each array element until the function returns a falsy value.
-         * If such an item is found, the function will return false immediately.
-         * Otherwise, it will return true.
-         *
-         * @param {Array} array
-         * @param {Function} fn Callback function for each item
-         * @param {Object} scope Callback function scope
-         * @return {Boolean} True if no false value is returned by the callback function.
-         */
-        every: function(array, fn, scope) {
-            //&lt;debug&gt;
-            if (!fn) {
-                Ext.Error.raise('Ext.Array.every must have a callback function passed as second argument.');
-            }
-            //&lt;/debug&gt;
-            if (supportsEvery) {
-                return array.every(fn, scope);
-            }
-
-            var i = 0,
-                ln = array.length;
-
-            for (; i &lt; ln; ++i) {
-                if (!fn.call(scope, array[i], i, array)) {
-                    return false;
-                }
-            }
-
-            return true;
-        },
-
-<span id='Ext-Array-method-some'>        /**
-</span>         * Executes the specified function for each array element until the function returns a truthy value.
-         * If such an item is found, the function will return true immediately. Otherwise, it will return false.
-         *
-         * @param {Array} array
-         * @param {Function} fn Callback function for each item
-         * @param {Object} scope Callback function scope
-         * @return {Boolean} True if the callback function returns a truthy value.
-         */
-        some: function(array, fn, scope) {
-            //&lt;debug&gt;
-            if (!fn) {
-                Ext.Error.raise('Ext.Array.some must have a callback function passed as second argument.');
-            }
-            //&lt;/debug&gt;
-            if (supportsSome) {
-                return array.some(fn, scope);
-            }
-
-            var i = 0,
-                ln = array.length;
-
-            for (; i &lt; ln; ++i) {
-                if (fn.call(scope, array[i], i, array)) {
-                    return true;
-                }
-            }
-
-            return false;
-        },
-
-<span id='Ext-Array-method-clean'>        /**
-</span>         * Filter through an array and remove empty item as defined in {@link Ext#isEmpty Ext.isEmpty}
-         *
-         * See {@link Ext.Array#filter}
-         *
-         * @param {Array} array
-         * @return {Array} results
-         */
-        clean: function(array) {
-            var results = [],
-                i = 0,
-                ln = array.length,
-                item;
-
-            for (; i &lt; ln; i++) {
-                item = array[i];
-
-                if (!Ext.isEmpty(item)) {
-                    results.push(item);
-                }
-            }
-
-            return results;
-        },
-
-<span id='Ext-Array-method-unique'>        /**
-</span>         * Returns a new array with unique items
-         *
-         * @param {Array} array
-         * @return {Array} results
-         */
-        unique: function(array) {
-            var clone = [],
-                i = 0,
-                ln = array.length,
-                item;
-
-            for (; i &lt; ln; i++) {
-                item = array[i];
-
-                if (ExtArray.indexOf(clone, item) === -1) {
-                    clone.push(item);
-                }
-            }
-
-            return clone;
-        },
-
-<span id='Ext-Array-method-filter'>        /**
-</span>         * Creates a new array with all of the elements of this array for which
-         * the provided filtering function returns true.
-         *
-         * @param {Array} array
-         * @param {Function} fn Callback function for each item
-         * @param {Object} scope Callback function scope
-         * @return {Array} results
-         */
-        filter: function(array, fn, scope) {
-            if (supportsFilter) {
-                return array.filter(fn, scope);
-            }
-
-            var results = [],
-                i = 0,
-                ln = array.length;
-
-            for (; i &lt; ln; i++) {
-                if (fn.call(scope, array[i], i, array)) {
-                    results.push(array[i]);
-                }
-            }
-
-            return results;
-        },
-
-<span id='Ext-Array-method-from'>        /**
-</span>         * Converts a value to an array if it's not already an array; returns:
-         *
-         * - An empty array if given value is `undefined` or `null`
-         * - Itself if given value is already an array
-         * - An array copy if given value is {@link Ext#isIterable iterable} (arguments, NodeList and alike)
-         * - An array with one item which is the given value, otherwise
-         *
-         * @param {Array/Mixed} value The value to convert to an array if it's not already is an array
-         * @param {Boolean} (Optional) newReference True to clone the given array and return a new reference if necessary,
-         * defaults to false
-         * @return {Array} array
-         */
-        from: function(value, newReference) {
-            if (value === undefined || value === null) {
-                return [];
-            }
-
-            if (Ext.isArray(value)) {
-                return (newReference) ? slice.call(value) : value;
-            }
-
-            if (value &amp;&amp; value.length !== undefined &amp;&amp; typeof value !== 'string') {
-                return Ext.toArray(value);
-            }
-
-            return [value];
-        },
-
-<span id='Ext-Array-method-remove'>        /**
-</span>         * Removes the specified item from the array if it exists
-         *
-         * @param {Array} array The array
-         * @param {Mixed} item The item to remove
-         * @return {Array} The passed array itself
-         */
-        remove: function(array, item) {
-            var index = ExtArray.indexOf(array, item);
-
-            if (index !== -1) {
-                erase(array, index, 1);
-            }
-
-            return array;
-        },
-
-<span id='Ext-Array-method-include'>        /**
-</span>         * Push an item into the array only if the array doesn't contain it yet
-         *
-         * @param {Array} array The array
-         * @param {Mixed} item The item to include
-         */
-        include: function(array, item) {
-            if (!ExtArray.contains(array, item)) {
-                array.push(item);
-            }
-        },
-
-<span id='Ext-Array-method-clone'>        /**
-</span>         * Clone a flat array without referencing the previous one. Note that this is different
-         * from Ext.clone since it doesn't handle recursive cloning. It's simply a convenient, easy-to-remember method
-         * for Array.prototype.slice.call(array)
-         *
-         * @param {Array} array The array
-         * @return {Array} The clone array
-         */
-        clone: function(array) {
-            return slice.call(array);
-        },
-
-<span id='Ext-Array-method-merge'>        /**
-</span>         * Merge multiple arrays into one with unique items.
-         *
-         * {@link Ext.Array#union} is alias for {@link Ext.Array#merge}
-         *
-         * @param {Array} array1
-         * @param {Array} array2
-         * @param {Array} etc
-         * @return {Array} merged
-         */
-        merge: function() {
-            var args = slice.call(arguments),
-                array = [],
-                i, ln;
-
-            for (i = 0, ln = args.length; i &lt; ln; i++) {
-                array = array.concat(args[i]);
-            }
-
-            return ExtArray.unique(array);
-        },
-
-<span id='Ext-Array-method-intersect'>        /**
-</span>         * Merge multiple arrays into one with unique items that exist in all of the arrays.
-         *
-         * @param {Array} array1
-         * @param {Array} array2
-         * @param {Array} etc
-         * @return {Array} intersect
-         */
-        intersect: function() {
-            var intersect = [],
-                arrays = slice.call(arguments),
-                i, j, k, minArray, array, x, y, ln, arraysLn, arrayLn;
-
-            if (!arrays.length) {
-                return intersect;
-            }
-
-            // Find the smallest array
-            for (i = x = 0,ln = arrays.length; i &lt; ln,array = arrays[i]; i++) {
-                if (!minArray || array.length &lt; minArray.length) {
-                    minArray = array;
-                    x = i;
-                }
-            }
-
-            minArray = ExtArray.unique(minArray);
-            erase(arrays, x, 1);
-
-            // Use the smallest unique'd array as the anchor loop. If the other array(s) do contain
-            // an item in the small array, we're likely to find it before reaching the end
-            // of the inner loop and can terminate the search early.
-            for (i = 0,ln = minArray.length; i &lt; ln,x = minArray[i]; i++) {
-                var count = 0;
-
-                for (j = 0,arraysLn = arrays.length; j &lt; arraysLn,array = arrays[j]; j++) {
-                    for (k = 0,arrayLn = array.length; k &lt; arrayLn,y = array[k]; k++) {
-                        if (x === y) {
-                            count++;
-                            break;
-                        }
-                    }
-                }
-
-                if (count === arraysLn) {
-                    intersect.push(x);
-                }
-            }
-
-            return intersect;
-        },
-
-<span id='Ext-Array-method-difference'>        /**
-</span>         * Perform a set difference A-B by subtracting all items in array B from array A.
-         *
-         * @param {Array} arrayA
-         * @param {Array} arrayB
-         * @return {Array} difference
-         */
-        difference: function(arrayA, arrayB) {
-            var clone = slice.call(arrayA),
-                ln = clone.length,
-                i, j, lnB;
-
-            for (i = 0,lnB = arrayB.length; i &lt; lnB; i++) {
-                for (j = 0; j &lt; ln; j++) {
-                    if (clone[j] === arrayB[i]) {
-                        erase(clone, j, 1);
-                        j--;
-                        ln--;
-                    }
-                }
-            }
-
-            return clone;
-        },
-
-<span id='Ext-Array-method-slice'>        /**
-</span>         * Returns a shallow copy of a part of an array. This is equivalent to the native
-         * call &quot;Array.prototype.slice.call(array, begin, end)&quot;. This is often used when &quot;array&quot;
-         * is &quot;arguments&quot; since the arguments object does not supply a slice method but can
-         * be the context object to Array.prototype.slice.
-         *
-         * @param {Array} array The array (or arguments object).
-         * @param {Number} begin The index at which to begin. Negative values are offsets from
-         * the end of the array.
-         * @param {Number} end The index at which to end. The copied items do not include
-         * end. Negative values are offsets from the end of the array. If end is omitted,
-         * all items up to the end of the array are copied.
-         * @return {Array} The copied piece of the array.
-         */
-        slice: function(array, begin, end) {
-            return slice.call(array, begin, end);
-        },
-
-<span id='Ext-Array-method-sort'>        /**
-</span>         * Sorts the elements of an Array.
-         * By default, this method sorts the elements alphabetically and ascending.
-         *
-         * @param {Array} array The array to sort.
-         * @param {Function} sortFn (optional) The comparison function.
-         * @return {Array} The sorted array.
-         */
-        sort: function(array, sortFn) {
-            if (supportsSort) {
-                if (sortFn) {
-                    return array.sort(sortFn);
-                } else {
-                    return array.sort();
-                }
-            }
-
-            var length = array.length,
-                i = 0,
-                comparison,
-                j, min, tmp;
-
-            for (; i &lt; length; i++) {
-                min = i;
-                for (j = i + 1; j &lt; length; j++) {
-                    if (sortFn) {
-                        comparison = sortFn(array[j], array[min]);
-                        if (comparison &lt; 0) {
-                            min = j;
-                        }
-                    } else if (array[j] &lt; array[min]) {
-                        min = j;
-                    }
-                }
-                if (min !== i) {
-                    tmp = array[i];
-                    array[i] = array[min];
-                    array[min] = tmp;
-                }
-            }
-
-            return array;
-        },
-
-<span id='Ext-Array-method-flatten'>        /**
-</span>         * Recursively flattens into 1-d Array. Injects Arrays inline.
-         *
-         */
-        flatten: function(array) {
-            var worker = [];
-
-            function rFlatten(a) {
-                var i, ln, v;
-
-                for (i = 0, ln = a.length; i &lt; ln; i++) {
-                    v = a[i];
-
-                    if (Ext.isArray(v)) {
-                        rFlatten(v);
-                    } else {
-                        worker.push(v);
-                    }
-                }
-
-                return worker;
-            }
-
-            return rFlatten(array);
-        },
-
-<span id='Ext-Array-method-min'>        /**
-</span>         * Returns the minimum value in the Array.
-         *
-         * @param {Array|NodeList} array The Array from which to select the minimum value.
-         * @param {Function} comparisonFn (optional) a function to perform the comparision which determines minimization.
-         * If omitted the &quot;&lt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
-         * @return {Mixed} minValue The minimum value
-         */
-        min: function(array, comparisonFn) {
-            var min = array[0],
-                i, ln, item;
-
-            for (i = 0, ln = array.length; i &lt; ln; i++) {
-                item = array[i];
-
-                if (comparisonFn) {
-                    if (comparisonFn(min, item) === 1) {
-                        min = item;
-                    }
-                }
-                else {
-                    if (item &lt; min) {
-                        min = item;
-                    }
-                }
-            }
-
-            return min;
-        },
-
-<span id='Ext-Array-method-max'>        /**
-</span>         * Returns the maximum value in the Array.
-         *
-         * @param {Array|NodeList} array The Array from which to select the maximum value.
-         * @param {Function} comparisonFn (optional) a function to perform the comparision which determines maximization.
-         * If omitted the &quot;&gt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
-         * @return {Mixed} maxValue The maximum value
-         */
-        max: function(array, comparisonFn) {
-            var max = array[0],
-                i, ln, item;
-
-            for (i = 0, ln = array.length; i &lt; ln; i++) {
-                item = array[i];
-
-                if (comparisonFn) {
-                    if (comparisonFn(max, item) === -1) {
-                        max = item;
-                    }
-                }
-                else {
-                    if (item &gt; max) {
-                        max = item;
-                    }
-                }
-            }
-
-            return max;
-        },
-
-<span id='Ext-Array-method-mean'>        /**
-</span>         * Calculates the mean of all items in the array.
-         *
-         * @param {Array} array The Array to calculate the mean value of.
-         * @return {Number} The mean.
-         */
-        mean: function(array) {
-            return array.length &gt; 0 ? ExtArray.sum(array) / array.length : undefined;
-        },
-
-<span id='Ext-Array-method-sum'>        /**
-</span>         * Calculates the sum of all items in the given array.
-         *
-         * @param {Array} array The Array to calculate the sum value of.
-         * @return {Number} The sum.
-         */
-        sum: function(array) {
-            var sum = 0,
-                i, ln, item;
-
-            for (i = 0,ln = array.length; i &lt; ln; i++) {
-                item = array[i];
-
-                sum += item;
-            }
-
-            return sum;
-        },
-
-        //&lt;debug&gt;
-        _replaceSim: replaceSim, // for unit testing
-        _spliceSim: spliceSim,
-        //&lt;/debug&gt;
-
-<span id='Ext-Array-method-erase'>        /**
-</span>         * Removes items from an array. This is functionally equivalent to the splice method
-         * of Array, but works around bugs in IE8's splice method and does not copy the
-         * removed elements in order to return them (because very often they are ignored).
-         *
-         * @param {Array} array The Array on which to replace.
-         * @param {Number} index The index in the array at which to operate.
-         * @param {Number} removeCount The number of items to remove at index.
-         * @return {Array} The array passed.
-         * @method
-         */
-        erase: erase,
-
-<span id='Ext-Array-method-insert'>        /**
-</span>         * Inserts items in to an array.
-         * 
-         * @param {Array} array The Array on which to replace.
-         * @param {Number} index The index in the array at which to operate.
-         * @param {Array} items The array of items to insert at index.
-         * @return {Array} The array passed.
-         */
-        insert: function (array, index, items) {
-            return replace(array, index, 0, items);
-        },
-
-<span id='Ext-Array-method-replace'>        /**
-</span>         * Replaces items in an array. This is functionally equivalent to the splice method
-         * of Array, but works around bugs in IE8's splice method and is often more convenient
-         * to call because it accepts an array of items to insert rather than use a variadic
-         * argument list.
-         * 
-         * @param {Array} array The Array on which to replace.
-         * @param {Number} index The index in the array at which to operate.
-         * @param {Number} removeCount The number of items to remove at index (can be 0).
-         * @param {Array} insert An optional array of items to insert at index.
-         * @return {Array} The array passed.
-         * @method
-         */
-        replace: replace,
-
-<span id='Ext-Array-method-splice'>        /**
-</span>         * Replaces items in an array. This is equivalent to the splice method of Array, but
-         * works around bugs in IE8's splice method. The signature is exactly the same as the
-         * splice method except that the array is the first argument. All arguments following
-         * removeCount are inserted in the array at index.
-         *
-         * @param {Array} array The Array on which to replace.
-         * @param {Number} index The index in the array at which to operate.
-         * @param {Number} removeCount The number of items to remove at index (can be 0).
-         * @return {Array} An array containing the removed items.
-         * @method
-         */
-        splice: splice
-    };
-
-<span id='Ext-method-each'>    /**
-</span>     * @method
-     * @member Ext
-     * @alias Ext.Array#each
-     */
-    Ext.each = ExtArray.each;
-
-<span id='Ext-Array-method-union'>    /**
-</span>     * @method
-     * @member Ext.Array
-     * @alias Ext.Array#merge
-     */
-    ExtArray.union = ExtArray.merge;
-
-<span id='Ext-method-min'>    /**
-</span>     * Old alias to {@link Ext.Array#min}
-     * @deprecated 4.0.0 Use {@link Ext.Array#min} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#min
-     */
-    Ext.min = ExtArray.min;
-
-<span id='Ext-method-max'>    /**
-</span>     * Old alias to {@link Ext.Array#max}
-     * @deprecated 4.0.0 Use {@link Ext.Array#max} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#max
-     */
-    Ext.max = ExtArray.max;
-
-<span id='Ext-method-sum'>    /**
-</span>     * Old alias to {@link Ext.Array#sum}
-     * @deprecated 4.0.0 Use {@link Ext.Array#sum} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#sum
-     */
-    Ext.sum = ExtArray.sum;
-
-<span id='Ext-method-mean'>    /**
-</span>     * Old alias to {@link Ext.Array#mean}
-     * @deprecated 4.0.0 Use {@link Ext.Array#mean} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#mean
-     */
-    Ext.mean = ExtArray.mean;
-
-<span id='Ext-method-flatten'>    /**
-</span>     * Old alias to {@link Ext.Array#flatten}
-     * @deprecated 4.0.0 Use {@link Ext.Array#flatten} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#flatten
-     */
-    Ext.flatten = ExtArray.flatten;
-
-<span id='Ext-method-clean'>    /**
-</span>     * Old alias to {@link Ext.Array#clean}
-     * @deprecated 4.0.0 Use {@link Ext.Array#clean} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#clean
-     */
-    Ext.clean = ExtArray.clean;
-
-<span id='Ext-method-unique'>    /**
-</span>     * Old alias to {@link Ext.Array#unique}
-     * @deprecated 4.0.0 Use {@link Ext.Array#unique} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#unique
-     */
-    Ext.unique = ExtArray.unique;
-
-<span id='Ext-method-pluck'>    /**
-</span>     * Old alias to {@link Ext.Array#pluck Ext.Array.pluck}
-     * @deprecated 4.0.0 Use {@link Ext.Array#pluck Ext.Array.pluck} instead
-     * @method
-     * @member Ext
-     * @alias Ext.Array#pluck
-     */
-    Ext.pluck = ExtArray.pluck;
-
-<span id='Ext-method-toArray'>    /**
-</span>     * @method
-     * @member Ext
-     * @alias Ext.Array#toArray
-     */
-    Ext.toArray = function() {
-        return ExtArray.toArray.apply(ExtArray, arguments);
-    };
-})();
+});
 </pre>
 </body>
 </html>