/**
                            Provides pre-built result highlighters for AutoComplete.
                            
                            @module autocomplete
                            @submodule autocomplete-highlighters
                            @class AutoCompleteHighlighters
                            @static
                            **/
                            
                            var YArray    = Y.Array,
                                Highlight = Y.Highlight,
                            
                            Highlighters = Y.mix(Y.namespace('AutoCompleteHighlighters'), {
                                // -- Public Methods -------------------------------------------------------
                            
                                /**
                                Highlights any individual query character that occurs anywhere in a result.
                                Case-insensitive.
                            
                                @method charMatch
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                charMatch: function (query, results, caseSensitive) {
                                    // The caseSensitive parameter is only intended for use by
                                    // charMatchCase(). It's intentionally undocumented.
                            
                                    var queryChars = YArray.unique((caseSensitive ? query :
                                            query.toLowerCase()).split(''));
                            
                                    return YArray.map(results, function (result) {
                                        return Highlight.all(result.text, queryChars, {
                                            caseSensitive: caseSensitive
                                        });
                                    });
                                },
                            
                                /**
                                Case-sensitive version of `charMatch()`.
                            
                                @method charMatchCase
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                charMatchCase: function (query, results) {
                                    return Highlighters.charMatch(query, results, true);
                                },
                            
                                /**
                                Highlights the complete query as a phrase anywhere within a result. Case-
                                insensitive.
                            
                                @method phraseMatch
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                phraseMatch: function (query, results, caseSensitive) {
                                    // The caseSensitive parameter is only intended for use by
                                    // phraseMatchCase(). It's intentionally undocumented.
                            
                                    return YArray.map(results, function (result) {
                                        return Highlight.all(result.text, [query], {
                                            caseSensitive: caseSensitive
                                        });
                                    });
                                },
                            
                                /**
                                Case-sensitive version of `phraseMatch()`.
                            
                                @method phraseMatchCase
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                phraseMatchCase: function (query, results) {
                                    return Highlighters.phraseMatch(query, results, true);
                                },
                            
                                /**
                                Highlights the complete query as a phrase at the beginning of a result.
                                Case-insensitive.
                            
                                @method startsWith
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                startsWith: function (query, results, caseSensitive) {
                                    // The caseSensitive parameter is only intended for use by
                                    // startsWithCase(). It's intentionally undocumented.
                            
                                    return YArray.map(results, function (result) {
                                        return Highlight.all(result.text, [query], {
                                            caseSensitive: caseSensitive,
                                            startsWith   : true
                                        });
                                    });
                                },
                            
                                /**
                                Case-sensitive version of `startsWith()`.
                            
                                @method startsWithCase
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                startsWithCase: function (query, results) {
                                    return Highlighters.startsWith(query, results, true);
                                },
                            
                                /**
                                Highlights portions of results in which words from the query match either
                                whole words or parts of words in the result. Non-word characters like
                                whitespace and certain punctuation are ignored. Case-insensitive.
                            
                                @method subWordMatch
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                subWordMatch: function (query, results, caseSensitive) {
                                    // The caseSensitive parameter is only intended for use by
                                    // subWordMatchCase(). It's intentionally undocumented.
                            
                                    var queryWords = Y.Text.WordBreak.getUniqueWords(query, {
                                        ignoreCase: !caseSensitive
                                    });
                            
                                    return YArray.map(results, function (result) {
                                        return Highlight.all(result.text, queryWords, {
                                            caseSensitive: caseSensitive
                                        });
                                    });
                                },
                            
                                /**
                                Case-sensitive version of `subWordMatch()`.
                            
                                @method subWordMatchCase
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                subWordMatchCase: function (query, results) {
                                    return Highlighters.subWordMatch(query, results, true);
                                },
                            
                                /**
                                Highlights individual words in results that are also in the query. Non-word
                                characters like punctuation are ignored. Case-insensitive.
                            
                                @method wordMatch
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                wordMatch: function (query, results, caseSensitive) {
                                    // The caseSensitive parameter is only intended for use by
                                    // wordMatchCase(). It's intentionally undocumented.
                            
                                    return YArray.map(results, function (result) {
                                        return Highlight.words(result.text, query, {
                                            caseSensitive: caseSensitive
                                        });
                                    });
                                },
                            
                                /**
                                Case-sensitive version of `wordMatch()`.
                            
                                @method wordMatchCase
                                @param {String} query Query to match
                                @param {Array} results Results to highlight
                                @return {Array} Highlighted results
                                @static
                                **/
                                wordMatchCase: function (query, results) {
                                    return Highlighters.wordMatch(query, results, true);
                                }
                            });