text: // Platform: ios
  // fc4db9145934bd0053161cbf9ffc0caf83b770c6
  /*
   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() {
  var PLATFORM_VERSION_BUILD_LABEL = '4.0.0-dev';
  // file: src/scripts/require.js
  
  /*jshint -W079 */
  /*jshint -W020 */
  
  var require,
      define;
  
  (function () {
      var modules = {},
      // Stack of moduleIds currently being built.
          requireStack = [],
      // Map of module ID -> index into requireStack of modules currently being built.
          inProgressModules = {},
          SEPARATOR = ".";
  
  
  
      function build(module) {
          var factory = module.factory,
              localRequire = function (id) {
                  var resultantId = id;
                  //Its a relative path, so lop off the last portion and add the id (minus "./")
                  if (id.charAt(0) === ".") {
                      resultantId = module.id.slice(0, module.id.lastIndexOf(SEPARATOR)) + SEPARATOR + id.slice(2);
                  }
                  return require(resultantId);
              };
          module.exports = {};
          delete module.factory;
          factory(localRequire, module.exports, module);
          return module.exports;
      }
  
      require = function (id) {
          if (!modules[id]) {
              throw "module " + id + " not found";
          } else if (id in inProgressModules) {
              var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
              throw "Cycle in require graph: " + cycle;
          }
          if (modules[id].factory) {
              try {
                  inProgressModules[id] = requireStack.length;
                  requireStack.push(id);
                  return build(modules[id]);
              } finally {
                  delete inProgressModules[id];
                  requireStack.pop();
              }
          }
          return 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];
      };
  
      define.moduleMap = modules;
  })();
  
  //Export for use in node
  if (typeof module === "object" && typeof require === "function") {
      module.exports.require = require;
      module.exports.define = define;
  }
  
  // file: src/cordova.js
  define("cordova", function(require, exports, module) {
  
  
  var channel = require('cordova/channel');
  var platform = require('cordova/platform');
  
  /**
   * 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') {
          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 unsubscribing 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 unsubscribing 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;
  }
  
  
  var cordova = {
      define:define,
      require:require,
      version:PLATFORM_VERSION_BUILD_LABEL,
      platformVersion:PLATFORM_VERSION_BUILD_LABEL,
      platformId:platform.id,
      /**
       * Methods to add/remove your own addEventListener hijacking on document + window.
       */
      addWindowEventHandler:function(event) {
          return (windowEventHandlers[event] = channel.create(event));
      },
      addStickyDocumentEventHandler:function(event) {
          return (documentEventHandlers[event] = channel.createSticky(event));
      },
      addDocumentEventHandler:function(event) {
          return (documentEventHandlers[event] = channel.create(event));
      },
      removeWindowEventHandler:function(event) {
          delete windowEventHandlers[event];
      },
      removeDocumentEventHandler:function(event) {
          delete documentEventHandlers[event];
      },
      /**
       * Retrieve 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
       * bNoDetach is required for events which cause an exception which needs to be caught in native code
       */
      fireDocumentEvent: function(type, data, bNoDetach) {
          var evt = createEvent(type, data);
          if (typeof documentEventHandlers[type] != 'undefined') {
              if( bNoDetach ) {
                  documentEventHandlers[type].fire(evt);
              }
              else {
                  setTimeout(function() {
                      // Fire deviceready on listeners that were registered before cordova.js was loaded.
                      if (type == 'deviceready') {
                          document.dispatchEvent(evt);
                      }
                      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);
          }
      },
  
      /**
       * Plugin callback mechanism.
       */
      // Randomize the starting callbackId to avoid collisions after refreshing or navigating.
      // This way, it's very unlikely that any new callback would get the same callbackId as an old callback.
      callbackId: Math.floor(Math.random() * 2000000000),
      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.
       */
      callbackSuccess: function(callbackId, args) {
          cordova.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback);
      },
  
      /**
       * Called by native code when returning error result from an action.
       */
      callbackError: function(callbackId, args) {
          // TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative.
          // Derive success from status.
          cordova.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback);
      },
  
      /**
       * Called by native code when returning the result from an action.
       */
      callbackFromNative: function(callbackId, isSuccess, status, args, keepCallback) {
          try {
              var callback = cordova.callbacks[callbackId];
              if (callback) {
                  if (isSuccess && status == cordova.callbackStatus.OK) {
                      callback.success && callback.success.apply(null, args);
                  } else if (!isSuccess) {
                      callback.fail && callback.fail.apply(null, args);
                  }
                  /*
                  else
                      Note, this case is intentionally not caught.
                      this can happen if isSuccess is true, but callbackStatus is NO_RESULT
                      which is used to remove a callback from the list without calling the callbacks
                      typically keepCallback is false in this case
                  */
                  // Clear callback if not expecting any more results
                  if (!keepCallback) {
                      delete cordova.callbacks[callbackId];
                  }
              }
          }
          catch (err) {
              var msg = "Error in " + (isSuccess ? "Success" : "Error") + " callbackId: " + callbackId + " : " + err;
              console && console.log && console.log(msg);
              cordova.fireWindowEvent("cordovacallbackerror", { 'message': msg });
              throw err;
          }
      },
      addConstructor: function(func) {
          channel.onCordovaReady.subscribe(function() {
              try {
                  func();
              } catch(e) {
                  console.log("Failed to run constructor: " + e);
              }
          });
      }
  };
  
  
  module.exports = cordova;
  
  });
  
  // file: src/common/argscheck.js
  define("cordova/argscheck", function(require, exports, module) {
  
  var exec = require('cordova/exec');
  var utils = require('cordova/utils');
  
  var moduleExports = module.exports;
  
  var typeMap = {
      'A': 'Array',
      'D': 'Date',
      'N': 'Number',
      'S': 'String',
      'F': 'Function',
      'O': 'Object'
  };
  
  function extractParamName(callee, argIndex) {
      return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex];
  }
  
  function checkArgs(spec, functionName, args, opt_callee) {
      if (!moduleExports.enableChecks) {
          return;
      }
      var errMsg = null;
      var typeName;
      for (var i = 0; i < spec.length; ++i) {
          var c = spec.charAt(i),
              cUpper = c.toUpperCase(),
              arg = args[i];
          // Asterix means allow anything.
          if (c == '*') {
              continue;
          }
          typeName = utils.typeName(arg);
          if ((arg === null || arg === undefined) && c == cUpper) {
              continue;
          }
          if (typeName != typeMap[cUpper]) {
              errMsg = 'Expected ' + typeMap[cUpper];
              break;
          }
      }
      if (errMsg) {
          errMsg += ', but got ' + typeName + '.';
          errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg;
          // Don't log when running unit tests.
          if (typeof jasmine == 'undefined') {
              console.error(errMsg);
          }
          throw TypeError(errMsg);
      }
  }
  
  function getValue(value, defaultValue) {
      return value === undefined ? defaultValue : value;
  }
  
  moduleExports.checkArgs = checkArgs;
  moduleExports.getValue = getValue;
  moduleExports.enableChecks = true;
  
  
  });
  
  // file: src/common/base64.js
  define("cordova/base64", function(require, exports, module) {
  
  var base64 = exports;
  
  base64.fromArrayBuffer = function(arrayBuffer) {
      var array = new Uint8Array(arrayBuffer);
      return uint8ToBase64(array);
  };
  
  base64.toArrayBuffer = function(str) {
      var decodedStr = typeof atob != 'undefined' ? atob(str) : new Buffer(str,'base64').toString('binary');
      var arrayBuffer = new ArrayBuffer(decodedStr.length);
      var array = new Uint8Array(arrayBuffer);
      for (var i=0, len=decodedStr.length; i < len; i++) {
          array[i] = decodedStr.charCodeAt(i);
      }
      return arrayBuffer;
  };
  
  //------------------------------------------------------------------------------
  
  /* This code is based on the performance tests at http://jsperf.com/b64tests
   * This 12-bit-at-a-time algorithm was the best performing version on all
   * platforms tested.
   */
  
  var b64_6bit = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var b64_12bit;
  
  var b64_12bitTable = function() {
      b64_12bit = [];
      for (var i=0; i<64; i++) {
          for (var j=0; j<64; j++) {
              b64_12bit[i*64+j] = b64_6bit[i] + b64_6bit[j];
          }
      }
      b64_12bitTable = function() { return b64_12bit; };
      return b64_12bit;
  };
  
  function uint8ToBase64(rawData) {
      var numBytes = rawData.byteLength;
      var output="";
      var segment;
      var table = b64_12bitTable();
      for (var i=0;i<numBytes-2;i+=3) {
          segment = (rawData[i] << 16) + (rawData[i+1] << 8) + rawData[i+2];
          output += table[segment >> 12];
          output += table[segment & 0xfff];
      }
      if (numBytes - i == 2) {
          segment = (rawData[i] << 16) + (rawData[i+1] << 8);
          output += table[segment >> 12];
          output += b64_6bit[(segment & 0xfff) >> 6];
          output += '=';
      } else if (numBytes - i == 1) {
          segment = (rawData[i] << 16);
          output += table[segment >> 12];
          output += '==';
      }
      return output;
  }
  
  });
  
  // file: src/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 clobber(obj, key, value) {
      exports.replaceHookForTesting(obj, key);
      var needsProperty = false;
      try {
          obj[key] = value;
      } catch (e) {
          needsProperty = true;
      }
      // Getters can only be overridden by getters.
      if (needsProperty || obj[key] !== value) {
          utils.defineGetter(obj, key, function() {
              return value;
          });
      }
  }
  
  function assignOrWrapInDeprecateGetter(obj, key, value, message) {
      if (message) {
          utils.defineGetter(obj, key, function() {
              console.log(message);
              delete obj[key];
              clobber(obj, key, value);
              return value;
          });
      } else {
          clobber(obj, key, value);
      }
  }
  
  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') {
                      assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                  } else if (typeof obj.path !== 'undefined') {
                      // If merging, merge properties onto parent, otherwise, clobber.
                      if (merge) {
                          recursiveMerge(parent[key], result);
                      } else {
                          assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                      }
                  }
                  result = parent[key];
              } else {
                  // Overwrite if not currently defined.
                  if (typeof parent[key] == 'undefined') {
                      assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
                  } 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 (target.prototype && target.prototype.constructor === target) {
                  // If the target object is a constructor override off prototype.
                  clobber(target.prototype, prop, src[prop]);
              } else {
                  if (typeof src[prop] === 'object' && typeof target[prop] === 'object') {
                      recursiveMerge(target[prop], src[prop]);
                  } else {
                      clobber(target, prop, src[prop]);
                  }
              }
          }
      }
  }
  
  exports.buildIntoButDoNotClobber = function(objects, target) {
      include(target, objects, false, false);
  };
  exports.buildIntoAndClobber = function(objects, target) {
      include(target, objects, true, false);
  };
  exports.buildIntoAndMerge = function(objects, target) {
      include(target, objects, true, true);
  };
  exports.recursiveMerge = recursiveMerge;
  exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter;
  exports.replaceHookForTesting = function() {};
  
  });
  
  // file: src/common/channel.js
  define("cordova/channel", function(require, exports, module) {
  
  var utils = require('cordova/utils'),
      nextGuid = 1;
  
  /**
   * 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, as well as for custom events thereafter.
   *
   * 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.
   * 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
   *
   * The events marked with an * are sticky. Once they have fired, they will stay in the fired state.
   * All listeners that subscribe after the event is fired will be executed right away.
   *
   * 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
   */
  var Channel = function(type, sticky) {
      this.type = type;
      // Map of guid -> function.
      this.handlers = {};
      // 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
      this.state = sticky ? 1 : 0;
      // Used in sticky mode to remember args passed to fire().
      this.fireArgs = null;
      // Used by onHasSubscribersChange to know if there are any listeners.
      this.numHandlers = 0;
      // Function that is called when the first listener is subscribed, or when
      // the last listener is unsubscribed.
      this.onHasSubscribersChange = null;
  },
      channel = {
          /**
           * Calls the provided function only after all of the channels specified
           * have been fired. All channels must be sticky channels.
           */
          join: function(h, c) {
              var len = c.length,
                  i = len,
                  f = function() {
                      if (!(--i)) h();
                  };
              for (var j=0; j<len; j++) {
                  if (c[j].state === 0) {
                      throw Error('Can only use join with sticky channels.');
                  }
                  c[j].subscribe(f);
              }
              if (!len) h();
          },
          create: function(type) {
              return channel[type] = new Channel(type, false);
          },
          createSticky: function(type) {
              return channel[type] = new Channel(type, true);
          },
  
          /**
           * 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 = channel[feature] || this.createSticky(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();
              }
          }
      };
  
  function forceFunction(f) {
      if (typeof f != 'function') throw "Function required as first argument!";
  }
  
  /**
   * Subscribes the given function to the channel. Any time that
   * Channel.fire is called so too will the function.
   * Optionally specify an execution context for the function
   * and a guid that can be used to stop subscribing to the channel.
   * Returns the guid.
   */
  Channel.prototype.subscribe = function(f, c) {
      // need a function to call
      forceFunction(f);
      if (this.state == 2) {
          f.apply(c || this, this.fireArgs);
          return;
      }
  
      var func = f,
          guid = f.observer_guid;
      if (typeof c == "object") { func = utils.close(c, f); }
  
      if (!guid) {
          // first time any channel has seen this subscriber
          guid = '' + nextGuid++;
      }
      func.observer_guid = guid;
      f.observer_guid = guid;
  
      // Don't add the same handler more than once.
      if (!this.handlers[guid]) {
          this.handlers[guid] = func;
          this.numHandlers++;
          if (this.numHandlers == 1) {
              this.onHasSubscribersChange && this.onHasSubscribersChange();
          }
      }
  };
  
  /**
   * Unsubscribes the function with the given guid from the channel.
   */
  Channel.prototype.unsubscribe = function(f) {
      // need a function to unsubscribe
      forceFunction(f);
  
      var guid = f.observer_guid,
          handler = this.handlers[guid];
      if (handler) {
          delete this.handlers[guid];
          this.numHandlers--;
          if (this.numHandlers === 0) {
              this.onHasSubscribersChange && this.onHasSubscribersChange();
          }
      }
  };
  
  /**
   * Calls all functions subscribed to this channel.
   */
  Channel.prototype.fire = function(e) {
      var fail = false,
          fireArgs = Array.prototype.slice.call(arguments);
      // Apply stickiness.
      if (this.state == 1) {
          this.state = 2;
          this.fireArgs = fireArgs;
      }
      if (this.numHandlers) {
          // Copy the values first so that it is safe to modify it from within
          // callbacks.
          var toCall = [];
          for (var item in this.handlers) {
              toCall.push(this.handlers[item]);
          }
          for (var i = 0; i < toCall.length; ++i) {
              toCall[i].apply(this, fireArgs);
          }
          if (this.state == 2 && this.numHandlers) {
              this.numHandlers = 0;
              this.handlers = {};
              this.onHasSubscribersChange && this.onHasSubscribersChange();
          }
      }
  };
  
  
  // defining them here so they are ready super fast!
  // DOM event that is received when the web page is loaded and parsed.
  channel.createSticky('onDOMContentLoaded');
  
  // Event to indicate the Cordova native side is ready.
  channel.createSticky('onNativeReady');
  
  // Event to indicate that all Cordova JavaScript objects have been created
  // and it's time to run plugin constructors.
  channel.createSticky('onCordovaReady');
  
  // Event to indicate that all automatically loaded JS plugins are loaded and ready.
  // FIXME remove this
  channel.createSticky('onPluginsReady');
  
  // Event to indicate that Cordova is ready
  channel.createSticky('onDeviceReady');
  
  // Event to indicate a resume lifecycle event
  channel.create('onResume');
  
  // Event to indicate a pause lifecycle event
  channel.create('onPause');
  
  // Channels that must fire before "deviceready" is fired.
  channel.waitForInitialization('onCordovaReady');
  channel.waitForInitialization('onDOMContentLoaded');
  
  module.exports = channel;
  
  });
  
  // file: src/ios/exec.js
  define("cordova/exec", function(require, exports, module) {
  
  /**
   * Creates a gap bridge iframe used to notify the native code about queued
   * commands.
   */
  var cordova = require('cordova'),
      channel = require('cordova/channel'),
      utils = require('cordova/utils'),
      base64 = require('cordova/base64'),
      // XHR mode does not work on iOS 4.2.
      // XHR mode's main advantage is working around a bug in -webkit-scroll, which
      // doesn't exist only on iOS 5.x devices.
      // IFRAME_NAV is the fastest.
      // IFRAME_HASH could be made to enable synchronous bridge calls if we wanted this feature.
      jsToNativeModes = {
          IFRAME_NAV: 0, // Default. Uses a new iframe for each poke.
          // XHR bridge appears to be flaky sometimes: CB-3900, CB-3359, CB-5457, CB-4970, CB-4998, CB-5134
          XHR_NO_PAYLOAD: 1, // About the same speed as IFRAME_NAV. Performance not about the same as IFRAME_NAV, but more variable.
          XHR_WITH_PAYLOAD: 2, // Flakey, and not as performant
          XHR_OPTIONAL_PAYLOAD: 3, // Flakey, and not as performant
          IFRAME_HASH_NO_PAYLOAD: 4, // Not fully baked. A bit faster than IFRAME_NAV, but risks jank since poke happens synchronously.
          IFRAME_HASH_WITH_PAYLOAD: 5, // Slower than no payload. Maybe since it has to be URI encoded / decoded.
          WK_WEBVIEW_BINDING: 6 // Only way that works for WKWebView :)
      },
      bridgeMode,
      execIframe,
      execHashIframe,
      hashToggle = 1,
      execXhr,
      requestCount = 0,
      vcHeaderValue = null,
      commandQueue = [], // Contains pending JS->Native messages.
      isInContextOfEvalJs = 0,
      failSafeTimerId = 0;
  
  function shouldBundleCommandJson() {
      if (bridgeMode === jsToNativeModes.XHR_WITH_PAYLOAD) {
          return true;
      }
      if (bridgeMode === jsToNativeModes.XHR_OPTIONAL_PAYLOAD) {
          var payloadLength = 0;
          for (var i = 0; i < commandQueue.length; ++i) {
              payloadLength += commandQueue[i].length;
          }
          // The value here was determined using the benchmark within CordovaLibApp on an iPad 3.
          return payloadLength < 4500;
      }
      return false;
  }
  
  function massageArgsJsToNative(args) {
      if (!args || utils.typeName(args) != 'Array') {
          return args;
      }
      var ret = [];
      args.forEach(function(arg, i) {
          if (utils.typeName(arg) == 'ArrayBuffer') {
              ret.push({
                  'CDVType': 'ArrayBuffer',
                  'data': base64.fromArrayBuffer(arg)
              });
          } else {
              ret.push(arg);
          }
      });
      return ret;
  }
  
  function massageMessageNativeToJs(message) {
      if (message.CDVType == 'ArrayBuffer') {
          var stringToArrayBuffer = function(str) {
              var ret = new Uint8Array(str.length);
              for (var i = 0; i < str.length; i++) {
                  ret[i] = str.charCodeAt(i);
              }
              return ret.buffer;
          };
          var base64ToArrayBuffer = function(b64) {
              return stringToArrayBuffer(atob(b64));
          };
          message = base64ToArrayBuffer(message.data);
      }
      return message;
  }
  
  function convertMessageToArgsNativeToJs(message) {
      var args = [];
      if (!message || !message.hasOwnProperty('CDVType')) {
          args.push(message);
      } else if (message.CDVType == 'MultiPart') {
          message.messages.forEach(function(e) {
              args.push(massageMessageNativeToJs(e));
          });
      } else {
          args.push(massageMessageNativeToJs(message));
      }
      return args;
  }
  
  function iOSExec() {
      if (bridgeMode === undefined) {
          if (navigator.userAgent) {
              bridgeMode = navigator.userAgent.indexOf(' 5_') == -1 ? jsToNativeModes.IFRAME_NAV: jsToNativeModes.XHR_NO_PAYLOAD;
  		} else {
          bridgeMode = jsToNativeModes.IFRAME_NAV;
          }
      }
  	
      if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.cordova && window.webkit.messageHandlers.cordova.postMessage) {
          bridgeMode = jsToNativeModes.WK_WEBVIEW_BINDING;
      }
      
      var successCallback, failCallback, service, action, actionArgs, splitCommand;
      var callbackId = null;
      if (typeof arguments[0] !== "string") {
          // FORMAT ONE
          successCallback = arguments[0];
          failCallback = arguments[1];
          service = arguments[2];
          action = arguments[3];
          actionArgs = arguments[4];
  
          // Since we need to maintain backwards compatibility, we have to pass
          // an invalid callbackId even if no callback was provided since plugins
          // will be expecting it. The Cordova.exec() implementation allocates
          // an invalid callbackId and passes it even if no callbacks were given.
          callbackId = 'INVALID';
      } else {
          // FORMAT TWO, REMOVED
          try {
              splitCommand = arguments[0].split(".");
              action = splitCommand.pop();
              service = splitCommand.join(".");
              actionArgs = Array.prototype.splice.call(arguments, 1);
  
              console.log('The old format of this exec call has been removed (deprecated since 2.1). Change to: ' +
                         "cordova.exec(null, null, \"" + service + "\", \"" + action + "\"," + JSON.stringify(actionArgs) + ");"
              );
              return;
          } catch (e) {}
      }
  
      // If actionArgs is not provided, default to an empty array
      actionArgs = actionArgs || [];
  
      // Register the callbacks and add the callbackId to the positional
      // arguments if given.
      if (successCallback || failCallback) {
          callbackId = service + cordova.callbackId++;
          cordova.callbacks[callbackId] =
              {success:successCallback, fail:failCallback};
      }
  
      actionArgs = massageArgsJsToNative(actionArgs);
  
      var command = [callbackId, service, action, actionArgs];
  
      if (bridgeMode === jsToNativeModes.WK_WEBVIEW_BINDING) {
          window.webkit.messageHandlers.cordova.postMessage(command);
      } else {
          // Stringify and queue the command. We stringify to command now to
          // effectively clone the command arguments in case they are mutated before
          // the command is executed.
          commandQueue.push(JSON.stringify(command));
  
          // If we're in the context of a stringByEvaluatingJavaScriptFromString call,
          // then the queue will be flushed when it returns; no need for a poke.
          // Also, if there is already a command in the queue, then we've already
          // poked the native side, so there is no reason to do so again.
          if (!isInContextOfEvalJs && commandQueue.length == 1) {
              pokeNative();
          }
      }
  }
  
  function pokeNative() {
      switch (bridgeMode) {
      case jsToNativeModes.XHR_NO_PAYLOAD:
      case jsToNativeModes.XHR_WITH_PAYLOAD:
      case jsToNativeModes.XHR_OPTIONAL_PAYLOAD:
          pokeNativeViaXhr();
          break;
      default: // iframe-based.
          pokeNativeViaIframe();
      }
  }
  
  function pokeNativeViaXhr() {
      // This prevents sending an XHR when there is already one being sent.
      // This should happen only in rare circumstances (refer to unit tests).
      if (execXhr && execXhr.readyState != 4) {
          execXhr = null;
      }
      // Re-using the XHR improves exec() performance by about 10%.
      execXhr = execXhr || new XMLHttpRequest();
      // Changing this to a GET will make the XHR reach the URIProtocol on 4.2.
      // For some reason it still doesn't work though...
      // Add a timestamp to the query param to prevent caching.
      execXhr.open('HEAD', "/!gap_exec?" + (+new Date()), true);
      if (!vcHeaderValue) {
          vcHeaderValue = /.*\((.*)\)$/.exec(navigator.userAgent)[1];
      }
      execXhr.setRequestHeader('vc', vcHeaderValue);
      execXhr.setRequestHeader('rc', ++requestCount);
      if (shouldBundleCommandJson()) {
          execXhr.setRequestHeader('cmds', iOSExec.nativeFetchMessages());
      }
      execXhr.send(null);
  }
  
  function pokeNativeViaIframe() {
      // CB-5488 - Don't attempt to create iframe before document.body is available.
      if (!document.body) {
          setTimeout(pokeNativeViaIframe);
          return;
      }
      if (bridgeMode === jsToNativeModes.IFRAME_HASH_NO_PAYLOAD || bridgeMode === jsToNativeModes.IFRAME_HASH_WITH_PAYLOAD) {
          // TODO: This bridge mode doesn't properly support being removed from the DOM (CB-7735)
          if (!execHashIframe) {
              execHashIframe = document.createElement('iframe');
              execHashIframe.style.display = 'none';
              document.body.appendChild(execHashIframe);
              // Hash changes don't work on about:blank, so switch it to file:///.
              execHashIframe.contentWindow.history.replaceState(null, null, 'file:///#');
          }
          // The delegate method is called only when the hash changes, so toggle it back and forth.
          hashToggle = hashToggle ^ 3;
          var hashValue = '%0' + hashToggle;
          if (bridgeMode === jsToNativeModes.IFRAME_HASH_WITH_PAYLOAD) {
              hashValue += iOSExec.nativeFetchMessages();
          }
          execHashIframe.contentWindow.location.hash = hashValue;
      } else {
          // Check if they've removed it from the DOM, and put it back if so.
          if (execIframe && execIframe.contentWindow) {
              execIframe.contentWindow.location = 'gap://ready';
          } else {
              execIframe = document.createElement('iframe');
              execIframe.style.display = 'none';
              execIframe.src = 'gap://ready';
              document.body.appendChild(execIframe);
          }
          // Use a timer to protect against iframe being unloaded during the poke (CB-7735).
          // This makes the bridge ~ 7% slower, but works around the poke getting lost
          // when the iframe is removed from the DOM.
          // An onunload listener could be used in the case where the iframe has just been
          // created, but since unload events fire only once, it doesn't work in the normal
          // case of iframe reuse (where unload will have already fired due to the attempted
          // navigation of the page).
          failSafeTimerId = setTimeout(function() {
              if (commandQueue.length) {
                  pokeNative();
              }
          }, 50); // Making this > 0 improves performance (marginally) in the normal case (where it doesn't fire).
      }
  }
  
  iOSExec.jsToNativeModes = jsToNativeModes;
  
  iOSExec.setJsToNativeBridgeMode = function(mode) {
      // Remove the iFrame since it may be no longer required, and its existence
      // can trigger browser bugs.
      // https://issues.apache.org/jira/browse/CB-593
      if (execIframe) {
          if (execIframe.parentNode) {
              execIframe.parentNode.removeChild(execIframe);
          }
          execIframe = null;
      }
      bridgeMode = mode;
  };
  
  iOSExec.nativeFetchMessages = function() {
      // Stop listing for window detatch once native side confirms poke.
      if (failSafeTimerId) {
          clearTimeout(failSafeTimerId);
          failSafeTimerId = 0;
      }
      // Each entry in commandQueue is a JSON string already.
      if (!commandQueue.length) {
          return '';
      }
      var json = '[' + commandQueue.join(',') + ']';
      commandQueue.length = 0;
      return json;
  };
  
  iOSExec.nativeCallback = function(callbackId, status, message, keepCallback) {
      return iOSExec.nativeEvalAndFetch(function() {
          var success = status === 0 || status === 1;
          var args = convertMessageToArgsNativeToJs(message);
          cordova.callbackFromNative(callbackId, success, status, args, keepCallback);
      });
  };
  
  iOSExec.nativeEvalAndFetch = function(func) {
      // This shouldn't be nested, but better to be safe.
      isInContextOfEvalJs++;
      try {
          func();
          return iOSExec.nativeFetchMessages();
      } finally {
          isInContextOfEvalJs--;
      }
  };
  
  module.exports = iOSExec;
  
  });
  
  // file: src/common/exec/proxy.js
  define("cordova/exec/proxy", function(require, exports, module) {
  
  
  // internal map of proxy function
  var CommandProxyMap = {};
  
  module.exports = {
  
      // example: cordova.commandProxy.add("Accelerometer",{getCurrentAcceleration: function(successCallback, errorCallback, options) {...},...);
      add:function(id,proxyObj) {
          console.log("adding proxy for " + id);
          CommandProxyMap[id] = proxyObj;
          return proxyObj;
      },
  
      // cordova.commandProxy.remove("Accelerometer");
      remove:function(id) {
          var proxy = CommandProxyMap[id];
          delete CommandProxyMap[id];
          CommandProxyMap[id] = null;
          return proxy;
      },
  
      get:function(service,action) {
          return ( CommandProxyMap[service] ? CommandProxyMap[service][action] : null );
      }
  };
  });
  
  // file: src/common/init.js
  define("cordova/init", function(require, exports, module) {
  
  var channel = require('cordova/channel');
  var cordova = require('cordova');
  var modulemapper = require('cordova/modulemapper');
  var platform = require('cordova/platform');
  var pluginloader = require('cordova/pluginloader');
  var utils = require('cordova/utils');
  
  var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady];
  
  function logUnfiredChannels(arr) {
      for (var i = 0; i < arr.length; ++i) {
          if (arr[i].state != 2) {
              console.log('Channel not fired: ' + arr[i].type);
          }
      }
  }
  
  window.setTimeout(function() {
      if (channel.onDeviceReady.state != 2) {
          console.log('deviceready has not fired after 5 seconds.');
          logUnfiredChannels(platformInitChannelsArray);
          logUnfiredChannels(channel.deviceReadyChannelsArray);
      }
  }, 5000);
  
  // Replace navigator before any modules are required(), to ensure it happens as soon as possible.
  // We replace it so that properties that can't be clobbered can instead be overridden.
  function replaceNavigator(origNavigator) {
      var CordovaNavigator = function() {};
      CordovaNavigator.prototype = origNavigator;
      var newNavigator = new CordovaNavigator();
      // This work-around really only applies to new APIs that are newer than Function.bind.
      // Without it, APIs such as getGamepads() break.
      if (CordovaNavigator.bind) {
          for (var key in origNavigator) {
              if (typeof origNavigator[key] == 'function') {
                  newNavigator[key] = origNavigator[key].bind(origNavigator);
              }
              else {
                  (function(k) {
                      utils.defineGetterSetter(newNavigator,key,function() {
                          return origNavigator[k];
                      });
                  })(key);
              }
          }
      }
      return newNavigator;
  }
  
  if (window.navigator) {
      window.navigator = replaceNavigator(window.navigator);
  }
  
  if (!window.console) {
      window.console = {
          log: function(){}
      };
  }
  if (!window.console.warn) {
      window.console.warn = function(msg) {
          this.log("warn: " + msg);
      };
  }
  
  // Register pause, resume and deviceready channels as events on document.
  channel.onPause = cordova.addDocumentEventHandler('pause');
  channel.onResume = cordova.addDocumentEventHandler('resume');
  channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
  
  // Listen for DOMContentLoaded and notify our channel subscribers.
  if (document.readyState == 'complete' || document.readyState == 'interactive') {
      channel.onDOMContentLoaded.fire();
  } else {
      document.addEventListener('DOMContentLoaded', function() {
          channel.onDOMContentLoaded.fire();
      }, false);
  }
  
  // _nativeReady is global variable that the native side can set
  // to signify that the native code is ready. It is a global since
  // it may be called before any cordova JS is ready.
  if (window._nativeReady) {
      channel.onNativeReady.fire();
  }
  
  modulemapper.clobbers('cordova', 'cordova');
  modulemapper.clobbers('cordova/exec', 'cordova.exec');
  modulemapper.clobbers('cordova/exec', 'Cordova.exec');
  
  // Call the platform-specific initialization.
  platform.bootstrap && platform.bootstrap();
  
  // Wrap in a setTimeout to support the use-case of having plugin JS appended to cordova.js.
  // The delay allows the attached modules to be defined before the plugin loader looks for them.
  setTimeout(function() {
      pluginloader.load(function() {
          channel.onPluginsReady.fire();
      });
  }, 0);
  
  /**
   * Create all cordova objects once native side is ready.
   */
  channel.join(function() {
      modulemapper.mapModules(window);
  
      platform.initialize && platform.initialize();
  
      // Fire event to notify that all objects are created
      channel.onCordovaReady.fire();
  
      // Fire onDeviceReady event once page has fully loaded, all
      // constructors have run and cordova info has been received from native
      // side.
      channel.join(function() {
          require('cordova').fireDocumentEvent('deviceready');
      }, channel.deviceReadyChannelsArray);
  
  }, platformInitChannelsArray);
  
  
  });
  
  // file: src/common/init_b.js
  define("cordova/init_b", function(require, exports, module) {
  
  var channel = require('cordova/channel');
  var cordova = require('cordova');
  var platform = require('cordova/platform');
  var utils = require('cordova/utils');
  
  var platformInitChannelsArray = [channel.onDOMContentLoaded, channel.onNativeReady];
  
  // setting exec
  cordova.exec = require('cordova/exec');
  
  function logUnfiredChannels(arr) {
      for (var i = 0; i < arr.length; ++i) {
          if (arr[i].state != 2) {
              console.log('Channel not fired: ' + arr[i].type);
          }
      }
  }
  
  window.setTimeout(function() {
      if (channel.onDeviceReady.state != 2) {
          console.log('deviceready has not fired after 5 seconds.');
          logUnfiredChannels(platformInitChannelsArray);
          logUnfiredChannels(channel.deviceReadyChannelsArray);
      }
  }, 5000);
  
  // Replace navigator before any modules are required(), to ensure it happens as soon as possible.
  // We replace it so that properties that can't be clobbered can instead be overridden.
  function replaceNavigator(origNavigator) {
      var CordovaNavigator = function() {};
      CordovaNavigator.prototype = origNavigator;
      var newNavigator = new CordovaNavigator();
      // This work-around really only applies to new APIs that are newer than Function.bind.
      // Without it, APIs such as getGamepads() break.
      if (CordovaNavigator.bind) {
          for (var key in origNavigator) {
              if (typeof origNavigator[key] == 'function') {
                  newNavigator[key] = origNavigator[key].bind(origNavigator);
              }
              else {
                  (function(k) {
                      utils.defineGetterSetter(newNavigator,key,function() {
                          return origNavigator[k];
                      });
                  })(key);
              }
          }
      }
      return newNavigator;
  }
  if (window.navigator) {
      window.navigator = replaceNavigator(window.navigator);
  }
  
  if (!window.console) {
      window.console = {
          log: function(){}
      };
  }
  if (!window.console.warn) {
      window.console.warn = function(msg) {
          this.log("warn: " + msg);
      };
  }
  
  // Register pause, resume and deviceready channels as events on document.
  channel.onPause = cordova.addDocumentEventHandler('pause');
  channel.onResume = cordova.addDocumentEventHandler('resume');
  channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
  
  // Listen for DOMContentLoaded and notify our channel subscribers.
  if (document.readyState == 'complete' || document.readyState == 'interactive') {
      channel.onDOMContentLoaded.fire();
  } else {
      document.addEventListener('DOMContentLoaded', function() {
          channel.onDOMContentLoaded.fire();
      }, false);
  }
  
  // _nativeReady is global variable that the native side can set
  // to signify that the native code is ready. It is a global since
  // it may be called before any cordova JS is ready.
  if (window._nativeReady) {
      channel.onNativeReady.fire();
  }
  
  // Call the platform-specific initialization.
  platform.bootstrap && platform.bootstrap();
  
  /**
   * Create all cordova objects once native side is ready.
   */
  channel.join(function() {
  
      platform.initialize && platform.initialize();
  
      // Fire event to notify that all objects are created
      channel.onCordovaReady.fire();
  
      // Fire onDeviceReady event once page has fully loaded, all
      // constructors have run and cordova info has been received from native
      // side.
      channel.join(function() {
          require('cordova').fireDocumentEvent('deviceready');
      }, channel.deviceReadyChannelsArray);
  
  }, platformInitChannelsArray);
  
  });
  
  // file: src/common/modulemapper.js
  define("cordova/modulemapper", function(require, exports, module) {
  
  var builder = require('cordova/builder'),
      moduleMap = define.moduleMap,
      symbolList,
      deprecationMap;
  
  exports.reset = function() {
      symbolList = [];
      deprecationMap = {};
  };
  
  function addEntry(strategy, moduleName, symbolPath, opt_deprecationMessage) {
      if (!(moduleName in moduleMap)) {
          throw new Error('Module ' + moduleName + ' does not exist.');
      }
      symbolList.push(strategy, moduleName, symbolPath);
      if (opt_deprecationMessage) {
          deprecationMap[symbolPath] = opt_deprecationMessage;
      }
  }
  
  // Note: Android 2.3 does have Function.bind().
  exports.clobbers = function(moduleName, symbolPath, opt_deprecationMessage) {
      addEntry('c', moduleName, symbolPath, opt_deprecationMessage);
  };
  
  exports.merges = function(moduleName, symbolPath, opt_deprecationMessage) {
      addEntry('m', moduleName, symbolPath, opt_deprecationMessage);
  };
  
  exports.defaults = function(moduleName, symbolPath, opt_deprecationMessage) {
      addEntry('d', moduleName, symbolPath, opt_deprecationMessage);
  };
  
  exports.runs = function(moduleName) {
      addEntry('r', moduleName, null);
  };
  
  function prepareNamespace(symbolPath, context) {
      if (!symbolPath) {
          return context;
      }
      var parts = symbolPath.split('.');
      var cur = context;
      for (var i = 0, part; part = parts[i]; ++i) {
          cur = cur[part] = cur[part] || {};
      }
      return cur;
  }
  
  exports.mapModules = function(context) {
      var origSymbols = {};
      context.CDV_origSymbols = origSymbols;
      for (var i = 0, len = symbolList.length; i < len; i += 3) {
          var strategy = symbolList[i];
          var moduleName = symbolList[i + 1];
          var module = require(moduleName);
          // <runs/>
          if (strategy == 'r') {
              continue;
          }
          var symbolPath = symbolList[i + 2];
          var lastDot = symbolPath.lastIndexOf('.');
          var namespace = symbolPath.substr(0, lastDot);
          var lastName = symbolPath.substr(lastDot + 1);
  
          var deprecationMsg = symbolPath in deprecationMap ? 'Access made to deprecated symbol: ' + symbolPath + '. ' + deprecationMsg : null;
          var parentObj = prepareNamespace(namespace, context);
          var target = parentObj[lastName];
  
          if (strategy == 'm' && target) {
              builder.recursiveMerge(target, module);
          } else if ((strategy == 'd' && !target) || (strategy != 'd')) {
              if (!(symbolPath in origSymbols)) {
                  origSymbols[symbolPath] = target;
              }
              builder.assignOrWrapInDeprecateGetter(parentObj, lastName, module, deprecationMsg);
          }
      }
  };
  
  exports.getOriginalSymbol = function(context, symbolPath) {
      var origSymbols = context.CDV_origSymbols;
      if (origSymbols && (symbolPath in origSymbols)) {
          return origSymbols[symbolPath];
      }
      var parts = symbolPath.split('.');
      var obj = context;
      for (var i = 0; i < parts.length; ++i) {
          obj = obj && obj[parts[i]];
      }
      return obj;
  };
  
  exports.reset();
  
  
  });
  
  // file: src/ios/platform.js
  define("cordova/platform", function(require, exports, module) {
  
  module.exports = {
      id: 'ios',
      bootstrap: function() {
          require('cordova/channel').onNativeReady.fire();
      }
  };
  
  
  });
  
  // file: src/common/pluginloader.js
  define("cordova/pluginloader", function(require, exports, module) {
  
  var modulemapper = require('cordova/modulemapper');
  var urlutil = require('cordova/urlutil');
  
  // Helper function to inject a <script> tag.
  // Exported for testing.
  exports.injectScript = function(url, onload, onerror) {
      var script = document.createElement("script");
      // onload fires even when script fails loads with an error.
      script.onload = onload;
      // onerror fires for malformed URLs.
      script.onerror = onerror;
      script.src = url;
      document.head.appendChild(script);
  };
  
  function injectIfNecessary(id, url, onload, onerror) {
      onerror = onerror || onload;
      if (id in define.moduleMap) {
          onload();
      } else {
          exports.injectScript(url, function() {
              if (id in define.moduleMap) {
                  onload();
              } else {
                  onerror();
              }
          }, onerror);
      }
  }
  
  function onScriptLoadingComplete(moduleList, finishPluginLoading) {
      // Loop through all the plugins and then through their clobbers and merges.
      for (var i = 0, module; module = moduleList[i]; i++) {
          if (module.clobbers && module.clobbers.length) {
              for (var j = 0; j < module.clobbers.length; j++) {
                  modulemapper.clobbers(module.id, module.clobbers[j]);
              }
          }
  
          if (module.merges && module.merges.length) {
              for (var k = 0; k < module.merges.length; k++) {
                  modulemapper.merges(module.id, module.merges[k]);
              }
          }
  
          // Finally, if runs is truthy we want to simply require() the module.
          if (module.runs) {
              modulemapper.runs(module.id);
          }
      }
  
      finishPluginLoading();
  }
  
  // Handler for the cordova_plugins.js content.
  // See plugman's plugin_loader.js for the details of this object.
  // This function is only called if the really is a plugins array that isn't empty.
  // Otherwise the onerror response handler will just call finishPluginLoading().
  function handlePluginsObject(path, moduleList, finishPluginLoading) {
      // Now inject the scripts.
      var scriptCounter = moduleList.length;
  
      if (!scriptCounter) {
          finishPluginLoading();
          return;
      }
      function scriptLoadedCallback() {
          if (!--scriptCounter) {
              onScriptLoadingComplete(moduleList, finishPluginLoading);
          }
      }
  
      for (var i = 0; i < moduleList.length; i++) {
          injectIfNecessary(moduleList[i].id, path + moduleList[i].file, scriptLoadedCallback);
      }
  }
  
  function findCordovaPath() {
      var path = null;
      var scripts = document.getElementsByTagName('script');
      var term = '/cordova.js';
      for (var n = scripts.length-1; n>-1; n--) {
          var src = scripts[n].src.replace(/\?.*$/, ''); // Strip any query param (CB-6007).
          if (src.indexOf(term) == (src.length - term.length)) {
              path = src.substring(0, src.length - term.length) + '/';
              break;
          }
      }
      return path;
  }
  
  // Tries to load all plugins' js-modules.
  // This is an async process, but onDeviceReady is blocked on onPluginsReady.
  // onPluginsReady is fired when there are no plugins to load, or they are all done.
  exports.load = function(callback) {
      var moduleList = require("cordova/plugin_list");
      if (!moduleList.length)
          callback();
      else
          onScriptLoadingComplete(moduleList, callback);
  };
  
  
  });
  
  // file: src/common/urlutil.js
  define("cordova/urlutil", function(require, exports, module) {
  
  
  /**
   * For already absolute URLs, returns what is passed in.
   * For relative URLs, converts them to absolute ones.
   */
  exports.makeAbsolute = function makeAbsolute(url) {
      var anchorEl = document.createElement('a');
      anchorEl.href = url;
      return anchorEl.href;
  };
  
  
  });
  
  // file: src/common/utils.js
  define("cordova/utils", function(require, exports, module) {
  
  var utils = exports;
  
  /**
   * Defines a property getter / setter for obj[key].
   */
  utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) {
      if (Object.defineProperty) {
          var desc = {
              get: getFunc,
              configurable: true
          };
          if (opt_setFunc) {
              desc.set = opt_setFunc;
          }
          Object.defineProperty(obj, key, desc);
      } else {
          obj.__defineGetter__(key, getFunc);
          if (opt_setFunc) {
              obj.__defineSetter__(key, opt_setFunc);
          }
      }
  };
  
  /**
   * Defines a property getter for obj[key].
   */
  utils.defineGetter = utils.defineGetterSetter;
  
  utils.arrayIndexOf = function(a, item) {
      if (a.indexOf) {
          return a.indexOf(item);
      }
      var len = a.length;
      for (var i = 0; i < len; ++i) {
          if (a[i] == item) {
              return i;
          }
      }
      return -1;
  };
  
  /**
   * Returns whether the item was found in the array.
   */
  utils.arrayRemove = function(a, item) {
      var index = utils.arrayIndexOf(a, item);
      if (index != -1) {
          a.splice(index, 1);
      }
      return index != -1;
  };
  
  utils.typeName = function(val) {
      return Object.prototype.toString.call(val).slice(8, -1);
  };
  
  /**
   * Returns an indication of whether the argument is an array or not
   */
  utils.isArray = function(a) {
      return utils.typeName(a) == 'Array';
  };
  
  /**
   * Returns an indication of whether the argument is a Date or not
   */
  utils.isDate = function(d) {
      return utils.typeName(d) == 'Date';
  };
  
  /**
   * Does a deep clone of the object.
   */
  utils.clone = function(obj) {
      if(!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') {
          return obj;
      }
  
      var retVal, i;
  
      if(utils.isArray(obj)){
          retVal = [];
          for(i = 0; i < obj.length; ++i){
              retVal.push(utils.clone(obj[i]));
          }
          return retVal;
      }
  
      retVal = {};
      for(i in obj){
          if(!(i in retVal) || retVal[i] != obj[i]) {
              retVal[i] = utils.clone(obj[i]);
          }
      }
      return retVal;
  };
  
  /**
   * Returns a wrapped version of the function
   */
  utils.close = function(context, func, params) {
      if (typeof params == 'undefined') {
          return function() {
              return func.apply(context, arguments);
          };
      } else {
          return function() {
              return func.apply(context, params);
          };
      }
  };
  
  /**
   * Create a UUID
   */
  utils.createUUID = function() {
      return UUIDcreatePart(4) + '-' +
          UUIDcreatePart(2) + '-' +
          UUIDcreatePart(2) + '-' +
          UUIDcreatePart(2) + '-' +
          UUIDcreatePart(6);
  };
  
  /**
   * Extends a child object from a parent object using classical inheritance
   * pattern.
   */
  utils.extend = (function() {
      // proxy used to establish prototype chain
      var F = function() {};
      // extend Child from Parent
      return function(Child, Parent) {
          F.prototype = Parent.prototype;
          Child.prototype = new F();
          Child.__super__ = Parent.prototype;
          Child.prototype.constructor = Child;
      };
  }());
  
  /**
   * Alerts a message in any available way: alert or console.log.
   */
  utils.alert = function(msg) {
      if (window.alert) {
          window.alert(msg);
      } else if (console && console.log) {
          console.log(msg);
      }
  };
  
  
  //------------------------------------------------------------------------------
  function UUIDcreatePart(length) {
      var uuidpart = "";
      for (var i=0; i<length; i++) {
          var uuidchar = parseInt((Math.random() * 256), 10).toString(16);
          if (uuidchar.length == 1) {
              uuidchar = "0" + uuidchar;
          }
          uuidpart += uuidchar;
      }
      return uuidpart;
  }
  
  
  });
  
  window.cordova = require('cordova');
  // file: src/scripts/bootstrap.js
  
  require('cordova/init');
  
  })();
  