// commit 114cf5304a74ff8f7c9ff1d21cf5652298af04b0

// File generated at :: Wed Jul 18 2012 16:47:25 GMT-0700 (PDT)

/*

 Licensed to the Apache Software Foundation (ASF) under one

 or more contributor license agreements.  See the NOTICE file

 distributed with this work for additional information

 regarding copyright ownership.  The ASF licenses this file

 to you under the Apache License, Version 2.0 (the

 "License"); you may not use this file except in compliance

 with the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing,

 software distributed under the License is distributed on an

 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 KIND, either express or implied.  See the License for the

 specific language governing permissions and limitations

 under the License.

*/

;(function() {

// file: lib/scripts/require.js

var require,

    define;

(function () {

    var modules = {};

    function build(module) {

        var factory = module.factory;

        module.exports = {};

        delete module.factory;

        factory(require, module.exports, module);

        return module.exports;

    }

    require = function (id) {

        if (!modules[id]) {

            throw "module " + id + " not found";

        }

        return modules[id].factory ? build(modules[id]) : modules[id].exports;

    };

    define = function (id, factory) {

        if (modules[id]) {

            throw "module " + id + " already defined";

        }

        modules[id] = {

            id: id,

            factory: factory

        };

    };

    define.remove = function (id) {

        delete modules[id];

    };

})();

//Export for use in node

if (typeof module === "object" && typeof require === "function") {

    module.exports.require = require;

    module.exports.define = define;

}

// file: lib/cordova.js

define("cordova", function(require, exports, module) {

var channel = require('cordova/channel');

/**

 * Listen for DOMContentLoaded and notify our channel subscribers.

 */

document.addEventListener('DOMContentLoaded', function() {

    channel.onDOMContentLoaded.fire();

}, false);

if (document.readyState == 'complete' || document.readyState == 'interactive') {

    channel.onDOMContentLoaded.fire();

}

/**

 * Intercept calls to addEventListener + removeEventListener and handle deviceready,

 * resume, and pause events.

 */

var m_document_addEventListener = document.addEventListener;

var m_document_removeEventListener = document.removeEventListener;

var m_window_addEventListener = window.addEventListener;

var m_window_removeEventListener = window.removeEventListener;

/**

 * Houses custom event handlers to intercept on document + window event listeners.

 */

var documentEventHandlers = {},

    windowEventHandlers = {};

document.addEventListener = function(evt, handler, capture) {

    var e = evt.toLowerCase();

    if (typeof documentEventHandlers[e] != 'undefined') {

        if (evt === 'deviceready') {

            documentEventHandlers[e].subscribeOnce(handler);

        } else {

            documentEventHandlers[e].subscribe(handler);

        }

    } else {

        m_document_addEventListener.call(document, evt, handler, capture);

    }

};

window.addEventListener = function(evt, handler, capture) {

    var e = evt.toLowerCase();

    if (typeof windowEventHandlers[e] != 'undefined') {

        windowEventHandlers[e].subscribe(handler);

    } else {

        m_window_addEventListener.call(window, evt, handler, capture);

    }

};

document.removeEventListener = function(evt, handler, capture) {

    var e = evt.toLowerCase();

    // If unsubcribing from an event that is handled by a plugin

    if (typeof documentEventHandlers[e] != "undefined") {

        documentEventHandlers[e].unsubscribe(handler);

    } else {

        m_document_removeEventListener.call(document, evt, handler, capture);

    }

};

window.removeEventListener = function(evt, handler, capture) {

    var e = evt.toLowerCase();

    // If unsubcribing from an event that is handled by a plugin

    if (typeof windowEventHandlers[e] != "undefined") {

        windowEventHandlers[e].unsubscribe(handler);

    } else {

        m_window_removeEventListener.call(window, evt, handler, capture);

    }

};

function createEvent(type, data) {

    var event = document.createEvent('Events');

    event.initEvent(type, false, false);

    if (data) {

        for (var i in data) {

            if (data.hasOwnProperty(i)) {

                event[i] = data[i];

            }

        }

    }

    return event;

}

if(typeof window.console === "undefined") {

    window.console = {

        log:function(){}

    };

}

var cordova = {

    define:define,

    require:require,

    /**

     * Methods to add/remove your own addEventListener hijacking on document + window.

     */

    addWindowEventHandler:function(event, opts) {

        return (windowEventHandlers[event] = channel.create(event, opts));

    },

    addDocumentEventHandler:function(event, opts) {

        return (documentEventHandlers[event] = channel.create(event, opts));

    },

    removeWindowEventHandler:function(event) {

        delete windowEventHandlers[event];

    },

    removeDocumentEventHandler:function(event) {

        delete documentEventHandlers[event];

    },

    /**

     * Retreive original event handlers that were replaced by Cordova

     *

     * @return object

     */

    getOriginalHandlers: function() {

        return {'document': {'addEventListener': m_document_addEventListener, 'removeEventListener': m_document_removeEventListener},

        'window': {'addEventListener': m_window_addEventListener, 'removeEventListener': m_window_removeEventListener}};

    },

    /**

     * Method to fire event from native code

     */

    fireDocumentEvent: function(type, data) {

        var evt = createEvent(type, data);

        if (typeof documentEventHandlers[type] != 'undefined') {

            setTimeout(function() {

                documentEventHandlers[type].fire(evt);

            }, 0);

        } else {

            document.dispatchEvent(evt);

        }

    },

    fireWindowEvent: function(type, data) {

        var evt = createEvent(type,data);

        if (typeof windowEventHandlers[type] != 'undefined') {

            setTimeout(function() {

                windowEventHandlers[type].fire(evt);

            }, 0);

        } else {

            window.dispatchEvent(evt);

        }

    },

    // TODO: this is Android only; think about how to do this better

    shuttingDown:false,

    UsePolling:false,

    // END TODO

    // TODO: iOS only

    // This queue holds the currently executing command and all pending

    // commands executed with cordova.exec().

    commandQueue:[],

    // Indicates if we're currently in the middle of flushing the command

    // queue on the native side.

    commandQueueFlushing:false,

    // END TODO

    /**

     * Plugin callback mechanism.

     */

    callbackId: 0,

    callbacks:  {},

    callbackStatus: {

        NO_RESULT: 0,

        OK: 1,

        CLASS_NOT_FOUND_EXCEPTION: 2,

        ILLEGAL_ACCESS_EXCEPTION: 3,

        INSTANTIATION_EXCEPTION: 4,

        MALFORMED_URL_EXCEPTION: 5,

        IO_EXCEPTION: 6,

        INVALID_ACTION: 7,

        JSON_EXCEPTION: 8,

        ERROR: 9

    },

    /**

     * Called by native code when returning successful result from an action.

     *

     * @param callbackId

     * @param args

     */

    callbackSuccess: function(callbackId, args) {

        if (cordova.callbacks[callbackId]) {

            // If result is to be sent to callback

            if (args.status == cordova.callbackStatus.OK) {

                try {

                    if (cordova.callbacks[callbackId].success) {

                        cordova.callbacks[callbackId].success(args.message);

                    }

                }

                catch (e) {

                    console.log("Error in success callback: "+callbackId+" = "+e);

                }

            }

            // Clear callback if not expecting any more results

            if (!args.keepCallback) {

                delete cordova.callbacks[callbackId];

            }

        }

    },

    /**

     * Called by native code when returning error result from an action.

     *

     * @param callbackId

     * @param args

     */

    callbackError: function(callbackId, args) {

        if (cordova.callbacks[callbackId]) {

            try {

                if (cordova.callbacks[callbackId].fail) {

                    cordova.callbacks[callbackId].fail(args.message);

                }

            }

            catch (e) {

                console.log("Error in error callback: "+callbackId+" = "+e);

            }

            // Clear callback if not expecting any more results

            if (!args.keepCallback) {

                delete cordova.callbacks[callbackId];

            }

        }

    },

    addConstructor: function(func) {

        channel.onCordovaReady.subscribeOnce(function() {

            try {

                func();

            } catch(e) {

                console.log("Failed to run constructor: " + e);

            }

        });

    }

};

// Register pause, resume and deviceready channels as events on document.

channel.onPause = cordova.addDocumentEventHandler('pause');

channel.onResume = cordova.addDocumentEventHandler('resume');

channel.onDeviceReady = cordova.addDocumentEventHandler('deviceready');

module.exports = cordova;

});

// file: lib/common/builder.js

define("cordova/builder", function(require, exports, module) {

var utils = require('cordova/utils');

function each(objects, func, context) {

    for (var prop in objects) {

        if (objects.hasOwnProperty(prop)) {

            func.apply(context, [objects[prop], prop]);

        }

    }

}

function include(parent, objects, clobber, merge) {

    each(objects, function (obj, key) {

        try {

          var result = obj.path ? require(obj.path) : {};

          if (clobber) {

              // Clobber if it doesn't exist.

              if (typeof parent[key] === 'undefined') {

                  parent[key] = result;

              } else if (typeof obj.path !== 'undefined') {

                  // If merging, merge properties onto parent, otherwise, clobber.

                  if (merge) {

                      recursiveMerge(parent[key], result);

                  } else {

                      parent[key] = result;

                  }

              }

              result = parent[key];

          } else {

            // Overwrite if not currently defined.

            if (typeof parent[key] == 'undefined') {

              parent[key] = result;

            } else if (merge && typeof obj.path !== 'undefined') {

              // If merging, merge parent onto result

              recursiveMerge(result, parent[key]);

              parent[key] = result;

            } else {

              // Set result to what already exists, so we can build children into it if they exist.

              result = parent[key];

            }

          }

          if (obj.children) {

            include(result, obj.children, clobber, merge);

          }

        } catch(e) {

          utils.alert('Exception building cordova JS globals: ' + e + ' for key "' + key + '"');

        }

    });

}

/**

 * Merge properties from one object onto another recursively.  Properties from

 * the src object will overwrite existing target property.

 *

 * @param target Object to merge properties into.

 * @param src Object to merge properties from.

 */

function recursiveMerge(target, src) {

    for (var prop in src) {

        if (src.hasOwnProperty(prop)) {

            if (typeof target.prototype !== 'undefined' && target.prototype.constructor === target) {

                // If the target object is a constructor override off prototype.

                target.prototype[prop] = src[prop];

            } else {

                target[prop] = typeof src[prop] === 'object' ? recursiveMerge(

                        target[prop], src[prop]) : src[prop];

            }

        }

    }

    return target;

}

module.exports = {

    build: function (objects) {

        return {

            intoButDontClobber: function (target) {

                include(target, objects, false, false);

            },

            intoAndClobber: function(target) {

                include(target, objects, true, false);

            },

            intoAndMerge: function(target) {

                include(target, objects, true, true);

            }

        };

    }

};

});

// file: lib/common/channel.js

define("cordova/channel", function(require, exports, module) {

var utils = require('cordova/utils');

/**

 * Custom pub-sub "channel" that can have functions subscribed to it

 * This object is used to define and control firing of events for

 * cordova initialization.

 *

 * The order of events during page load and Cordova startup is as follows:

 *

 * onDOMContentLoaded         Internal event that is received when the web page is loaded and parsed.

 * onNativeReady              Internal event that indicates the Cordova native side is ready.

 * onCordovaReady             Internal event fired when all Cordova JavaScript objects have been created.

 * onCordovaInfoReady         Internal event fired when device properties are available.

 * onCordovaConnectionReady   Internal event fired when the connection property has been set.

 * onDeviceReady              User event fired to indicate that Cordova is ready

 * onResume                   User event fired to indicate a start/resume lifecycle event

 * onPause                    User event fired to indicate a pause lifecycle event

 * onDestroy                  Internal event fired when app is being destroyed (User should use window.onunload event, not this one).

 *

 * The only Cordova events that user code should register for are:

 *      deviceready           Cordova native code is initialized and Cordova APIs can be called from JavaScript

 *      pause                 App has moved to background

 *      resume                App has returned to foreground

 *

 * Listeners can be registered as:

 *      document.addEventListener("deviceready", myDeviceReadyListener, false);

 *      document.addEventListener("resume", myResumeListener, false);

 *      document.addEventListener("pause", myPauseListener, false);

 *

 * The DOM lifecycle events should be used for saving and restoring state

 *      window.onload

 *      window.onunload

 *

 */

/**

 * Channel

 * @constructor

 * @param type  String the channel name

 * @param opts  Object options to pass into the channel, currently

 *                     supports:

 *                     onSubscribe: callback that fires when

 *                       something subscribes to the Channel. Sets

 *                       context to the Channel.

 *                     onUnsubscribe: callback that fires when

 *                       something unsubscribes to the Channel. Sets

 *                       context to the Channel.

 */

var Channel = function(type, opts) {

    this.type = type;

    this.handlers = {};

    this.numHandlers = 0;

    this.guid = 1;

    this.fired = false;

    this.enabled = true;

    this.events = {

        onSubscribe:null,

        onUnsubscribe:null

    };

    if (opts) {

        if (opts.onSubscribe) this.events.onSubscribe = opts.onSubscribe;

        if (opts.onUnsubscribe) this.events.onUnsubscribe = opts.onUnsubscribe;

    }

},

    channel = {

        /**

         * Calls the provided function only after all of the channels specified

         * have been fired.

         */

        join: function (h, c) {

            var i = c.length;

            var len = i;

            var f = function() {

                if (!(--i)) h();

            };

            for (var j=0; j<len; j++) {

                !c[j].fired?c[j].subscribeOnce(f):i--;

            }

            if (!i) h();

        },

        create: function (type, opts) {

            channel[type] = new Channel(type, opts);

            return channel[type];

        },

        /**

         * cordova Channels that must fire before "deviceready" is fired.

         */

        deviceReadyChannelsArray: [],

        deviceReadyChannelsMap: {},

        /**

         * Indicate that a feature needs to be initialized before it is ready to be used.

         * This holds up Cordova's "deviceready" event until the feature has been initialized

         * and Cordova.initComplete(feature) is called.

         *

         * @param feature {String}     The unique feature name

         */

        waitForInitialization: function(feature) {

            if (feature) {

                var c = null;

                if (this[feature]) {

                    c = this[feature];

                }

                else {

                    c = this.create(feature);

                }

                this.deviceReadyChannelsMap[feature] = c;

                this.deviceReadyChannelsArray.push(c);

            }

        },

        /**

         * Indicate that initialization code has completed and the feature is ready to be used.

         *

         * @param feature {String}     The unique feature name

         */

        initializationComplete: function(feature) {

            var c = this.deviceReadyChannelsMap[feature];

            if (c) {

                c.fire();

            }

        }