cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From audre...@apache.org
Subject [2/7] cordova-windows git commit: CB-12895 : setup eslint and removed jshint
Date Fri, 14 Jul 2017 22:57:42 GMT
http://git-wip-us.apache.org/repos/asf/cordova-windows/blob/a8692238/template/www/cordova.js
----------------------------------------------------------------------
diff --git a/template/www/cordova.js b/template/www/cordova.js
index 222e9d8..778efd2 100644
--- a/template/www/cordova.js
+++ b/template/www/cordova.js
@@ -1,4 +1,4 @@
-// Platform: windows
+// Platform: windows
 // 7c5fcc5a5adfbf3fb8ceaf36fbdd4bd970bd9c20
 /*
  Licensed to the Apache Software Foundation (ASF) under one
@@ -8,9 +8,9 @@
  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
@@ -18,2429 +18,2393 @@
  specific language governing permissions and limitations
  under the License.
 */
-;(function() {
-var PLATFORM_VERSION_BUILD_LABEL = '5.1.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 PLATFORM_VERSION_BUILD_LABEL = '5.1.0-dev';
+    // file: src/scripts/require.js
+
+    var require;
+    var define;
+
+    (function () {
+        var modules = {};
+        // Stack of moduleIds currently being built.
+        var requireStack = [];
+        // Map of module ID -> index into requireStack of modules currently being built.
+        var inProgressModules = {};
+        var SEPARATOR = '.';
+
+        function build (module) {
+            var factory = module.factory;
+            var 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) === ".") {
+                // 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();
+            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;
             }
-        }
-        return modules[id].exports;
-    };
+            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";
-        }
+        define = function (id, factory) {
+            if (modules[id]) {
+                throw 'module ' + id + ' already defined';
+            }
 
-        modules[id] = {
-            id: id,
-            factory: factory
+            modules[id] = {
+                id: id,
+                factory: factory
+            };
         };
-    };
 
-    define.remove = function (id) {
-        delete modules[id];
-    };
+        define.remove = function (id) {
+            delete modules[id];
+        };
 
-    define.moduleMap = modules;
-})();
+        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) {
-
-// Workaround for Windows 10 in hosted environment case
-// http://www.w3.org/html/wg/drafts/html/master/browsers.html#named-access-on-the-window-object
-if (window.cordova && !(window.cordova instanceof HTMLElement)) {
-    throw new Error("cordova already defined");
-}
-
-
-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);
+    // Export for use in node
+    if (typeof module === 'object' && typeof require === 'function') {
+        module.exports.require = require;
+        module.exports.define = define;
     }
-};
-
-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];
-            }
+    // file: src/cordova.js
+    define('cordova', function (require, exports, module) {
+
+        // Workaround for Windows 10 in hosted environment case
+        // http://www.w3.org/html/wg/drafts/html/master/browsers.html#named-access-on-the-window-object
+        if (window.cordova && !(window.cordova instanceof HTMLElement)) {
+            throw new Error('cordova already defined');
         }
-    }
-    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);
+
+        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 = {};
+        var 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);
             }
-        } 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];
-                }
+        };
+
+        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);
             }
-        }
-        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);
+        };
+
+        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);
+            }
+        };
 
-module.exports = cordova;
+        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 utils = require('cordova/utils');
+    // file: src/common/argscheck.js
+    define('cordova/argscheck', function (require, exports, module) {
 
-var moduleExports = module.exports;
+        var utils = require('cordova/utils');
 
-var typeMap = {
-    'A': 'Array',
-    'D': 'Date',
-    'N': 'Number',
-    'S': 'String',
-    'F': 'Function',
-    'O': 'Object'
-};
+        var moduleExports = module.exports;
 
-function extractParamName(callee, argIndex) {
-    return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex];
-}
+        var typeMap = {
+            'A': 'Array',
+            'D': 'Date',
+            'N': 'Number',
+            'S': 'String',
+            'F': 'Function',
+            'O': 'Object'
+        };
 
-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;
+        function extractParamName (callee, argIndex) {
+            return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex];
         }
-        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);
+
+        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);
+                var cUpper = c.toUpperCase();
+                var 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);
+            }
         }
-        throw TypeError(errMsg);
-    }
-}
 
-function getValue(value, defaultValue) {
-    return value === undefined ? defaultValue : value;
-}
+        function getValue (value, defaultValue) {
+            return value === undefined ? defaultValue : value;
+        }
 
-moduleExports.checkArgs = checkArgs;
-moduleExports.getValue = getValue;
-moduleExports.enableChecks = true;
+        moduleExports.checkArgs = checkArgs;
+        moduleExports.getValue = getValue;
+        moduleExports.enableChecks = true;
 
+    });
 
-});
+    // file: src/common/base64.js
+    define('cordova/base64', function (require, exports, module) {
 
-// file: src/common/base64.js
-define("cordova/base64", function(require, exports, module) {
+        var base64 = exports;
 
-var base64 = exports;
+        base64.fromArrayBuffer = function (arrayBuffer) {
+            var array = new Uint8Array(arrayBuffer);
+            return uint8ToBase64(array);
+        };
 
-base64.fromArrayBuffer = function(arrayBuffer) {
-    var array = new Uint8Array(arrayBuffer);
-    return uint8ToBase64(array);
-};
+        base64.toArrayBuffer = function (str) {
+            var decodedStr = typeof atob !== 'undefined' ? atob(str) : Buffer.from(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;
+        };
 
-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.
+         */
 
-/* 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_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;
+        };
 
-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];
+        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;
         }
-    }
-    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) {
+    // file: src/common/builder.js
+    define('cordova/builder', function (require, exports, module) {
 
-var utils = require('cordova/utils');
+        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];
+        function each (objects, func, context) {
+            for (var prop in objects) {
+                if (objects.hasOwnProperty(prop)) {
+                    func.apply(context, [objects[prop], prop]);
                 }
             }
+        }
 
-            if (obj.children) {
-                include(result, obj.children, clobber, merge);
+        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;
+                });
             }
-        } 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]);
+
+        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 {
-                if (typeof src[prop] === 'object' && typeof target[prop] === 'object') {
-                    recursiveMerge(target[prop], src[prop]);
-                } else {
-                    clobber(target, prop, src[prop]);
+                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 = {
+
+        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');
+        var nextGuid = 1;
+
         /**
-         * Calls the provided function only after all of the channels specified
-         * have been fired. All channels must be sticky channels.
+         * 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
          */
-        join: function(h, c) {
-            var len = c.length,
-                i = len,
-                f = function() {
+        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;
+        };
+        var 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;
+                var i = len;
+                var 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.');
+                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); /* eslint no-return-assign : 0 */
+            },
+            createSticky: function (type) {
+                return channel[type] = new Channel(type, true); /* eslint no-return-assign : 0 */
+            },
+
+            /**
+             * 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);
                 }
-                c[j].subscribe(f);
+            },
+
+            /**
+             * 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 checkSubscriptionArgument (argument) {
+            if (typeof argument !== 'function' && typeof argument.handleEvent !== 'function') {
+                throw new Error(
+                    'Must provide a function or an EventListener object ' +
+                    'implementing the handleEvent interface.'
+                );
             }
-            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.
+         * 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.
          */
-        deviceReadyChannelsArray: [],
-        deviceReadyChannelsMap: {},
+        Channel.prototype.subscribe = function (eventListenerOrFunction, eventListener) {
+            checkSubscriptionArgument(eventListenerOrFunction);
+            var handleEvent, guid;
+
+            if (eventListenerOrFunction && typeof eventListenerOrFunction === 'object') {
+                // Received an EventListener object implementing the handleEvent interface
+                handleEvent = eventListenerOrFunction.handleEvent;
+                eventListener = eventListenerOrFunction;
+            } else {
+                // Received a function to handle event
+                handleEvent = eventListenerOrFunction;
+            }
+
+            if (this.state === 2) {
+                handleEvent.apply(eventListener || this, this.fireArgs);
+                return;
+            }
+
+            guid = eventListenerOrFunction.observer_guid;
+            if (typeof eventListener === 'object') {
+                handleEvent = utils.close(eventListener, handleEvent);
+            }
+
+            if (!guid) {
+                // First time any channel has seen this subscriber
+                guid = '' + nextGuid++;
+            }
+            handleEvent.observer_guid = guid;
+            eventListenerOrFunction.observer_guid = guid;
+
+            // Don't add the same handler more than once.
+            if (!this.handlers[guid]) {
+                this.handlers[guid] = handleEvent;
+                this.numHandlers++;
+                if (this.numHandlers === 1) {
+                    this.onHasSubscribersChange && this.onHasSubscribersChange();
+                }
+            }
+        };
 
         /**
-         * 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
+         * Unsubscribes the function with the given guid from the channel.
          */
-        waitForInitialization: function(feature) {
-            if (feature) {
-                var c = channel[feature] || this.createSticky(feature);
-                this.deviceReadyChannelsMap[feature] = c;
-                this.deviceReadyChannelsArray.push(c);
+        Channel.prototype.unsubscribe = function (eventListenerOrFunction) {
+            checkSubscriptionArgument(eventListenerOrFunction);
+            var handleEvent, guid, handler;
+
+            if (eventListenerOrFunction && typeof eventListenerOrFunction === 'object') {
+                // Received an EventListener object implementing the handleEvent interface
+                handleEvent = eventListenerOrFunction.handleEvent;
+            } else {
+                // Received a function to handle event
+                handleEvent = eventListenerOrFunction;
             }
-        },
+
+            guid = handleEvent.observer_guid;
+            handler = this.handlers[guid];
+            if (handler) {
+                delete this.handlers[guid];
+                this.numHandlers--;
+                if (this.numHandlers === 0) {
+                    this.onHasSubscribersChange && this.onHasSubscribersChange();
+                }
+            }
+        };
 
         /**
-         * Indicate that initialization code has completed and the feature is ready to be used.
-         *
-         * @param feature {String}     The unique feature name
+         * Calls all functions subscribed to this channel.
          */
-        initializationComplete: function(feature) {
-            var c = this.deviceReadyChannelsMap[feature];
-            if (c) {
-                c.fire();
+        Channel.prototype.fire = function (e) {
+            var fail = false; /* eslint no-unused-vars : 0 */
+            var fireArgs = Array.prototype.slice.call(arguments);
+            // Apply stickiness.
+            if (this.state === 1) {
+                this.state = 2;
+                this.fireArgs = fireArgs;
             }
-        }
-    };
-
-function checkSubscriptionArgument(argument) {
-    if (typeof argument !== "function" && typeof argument.handleEvent !== "function") {
-        throw new Error(
-                "Must provide a function or an EventListener object " +
-                "implementing the handleEvent interface."
-        );
-    }
-}
-
-/**
- * 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(eventListenerOrFunction, eventListener) {
-    checkSubscriptionArgument(eventListenerOrFunction);
-    var handleEvent, guid;
-
-    if (eventListenerOrFunction && typeof eventListenerOrFunction === "object") {
-        // Received an EventListener object implementing the handleEvent interface
-        handleEvent = eventListenerOrFunction.handleEvent;
-        eventListener = eventListenerOrFunction;
-    } else {
-        // Received a function to handle event
-        handleEvent = eventListenerOrFunction;
-    }
+            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();
+                }
+            }
+        };
 
-    if (this.state == 2) {
-        handleEvent.apply(eventListener || this, this.fireArgs);
-        return;
-    }
+        // 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');
 
-    guid = eventListenerOrFunction.observer_guid;
-    if (typeof eventListener === "object") {
-        handleEvent = utils.close(eventListener, handleEvent);
-    }
+        // Event to indicate the Cordova native side is ready.
+        channel.createSticky('onNativeReady');
 
-    if (!guid) {
-        // First time any channel has seen this subscriber
-        guid = '' + nextGuid++;
-    }
-    handleEvent.observer_guid = guid;
-    eventListenerOrFunction.observer_guid = guid;
-
-    // Don't add the same handler more than once.
-    if (!this.handlers[guid]) {
-        this.handlers[guid] = handleEvent;
-        this.numHandlers++;
-        if (this.numHandlers == 1) {
-            this.onHasSubscribersChange && this.onHasSubscribersChange();
-        }
-    }
-};
-
-/**
- * Unsubscribes the function with the given guid from the channel.
- */
-Channel.prototype.unsubscribe = function(eventListenerOrFunction) {
-    checkSubscriptionArgument(eventListenerOrFunction);
-    var handleEvent, guid, handler;
-
-    if (eventListenerOrFunction && typeof eventListenerOrFunction === "object") {
-        // Received an EventListener object implementing the handleEvent interface
-        handleEvent = eventListenerOrFunction.handleEvent;
-    } else {
-        // Received a function to handle event
-        handleEvent = eventListenerOrFunction;
-    }
+        // 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');
 
-    guid = handleEvent.observer_guid;
-    handler = this.handlers[guid];
-    if (handler) {
-        delete this.handlers[guid];
-        this.numHandlers--;
-        if (this.numHandlers === 0) {
-            this.onHasSubscribersChange && this.onHasSubscribersChange();
+        // 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: f:/coho/cordova-windows/cordova-js-src/confighelper.js
+    define('cordova/confighelper', function (require, exports, module) {
+
+        // config.xml and AppxManifest.xml wrapper (non-node ConfigParser analogue)
+        var configCache = {};
+        var utils = require('cordova/utils');
+
+        var isPhone = (cordova.platformId === 'windows') && WinJS.Utilities.isPhone;
+        var isWin10UWP = navigator.appVersion.indexOf('MSAppHost/3.0') !== -1;
+        var splashScreenTagName = isWin10UWP ? 'SplashScreen' : (isPhone ? 'm3:SplashScreen' : 'm2:SplashScreen');
+
+        function XmlFile (text) {
+            this.text = text;
         }
-    }
-};
-
-/**
- * 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]);
+
+        XmlFile.prototype.loadTags = function (tagName) {
+            var parser;
+            if (!this.doc) {
+                parser = new DOMParser();
+                this.doc = parser.parseFromString(this.text, 'application/xml');
+            }
+
+            var tags = this.doc.getElementsByTagName(tagName);
+            return Array.prototype.slice.call(tags);
+        };
+
+        function Config (text) {
+            XmlFile.apply(this, arguments);
+            this.preferences = this.loadTags('preference');
         }
-        for (var i = 0; i < toCall.length; ++i) {
-            toCall[i].apply(this, fireArgs);
+
+        function Manifest (text) {
+            XmlFile.apply(this, arguments);
+            this.splashScreen = this.loadTags(splashScreenTagName)[0];
         }
-        if (this.state == 2 && this.numHandlers) {
-            this.numHandlers = 0;
-            this.handlers = {};
-            this.onHasSubscribersChange && this.onHasSubscribersChange();
+
+        utils.extend(Config, XmlFile);
+        utils.extend(Manifest, XmlFile);
+
+        function requestFile (filePath, success, error) {
+            var xhr;
+
+            if (typeof configCache[filePath] !== 'undefined') {
+                success(configCache[filePath]);
+            }
+
+            function fail (msg) {
+                console.error(msg);
+
+                if (error) {
+                    error(msg);
+                }
+            }
+
+            var xhrStatusChangeHandler = function () {
+                if (xhr.readyState === 4) {
+                    if (xhr.status === 200 || xhr.status === 304 || xhr.status === 0 /* file:// */) {
+                        configCache[filePath] = xhr.responseText;
+                        success(xhr.responseText);
+                    } else {
+                        fail('[Windows][cordova.js][xhrStatusChangeHandler] Could not XHR ' + filePath + ': ' + xhr.statusText);
+                    }
+                }
+            };
+
+            xhr = new XMLHttpRequest(); /* eslint no-undef: 0 */
+            xhr.addEventListener('load', xhrStatusChangeHandler);
+
+            try {
+                xhr.open('get', filePath, true);
+                xhr.send();
+            } catch (e) {
+                fail('[Windows][cordova.js][xhrFile] Could not XHR ' + filePath + ': ' + JSON.stringify(e));
+            }
         }
-    }
-};
 
+        function readConfig (success, error) {
+            requestFile('/config.xml', function (contents) {
+                success(new Config(contents));
+            }, error);
+        }
 
-// 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');
+        function readManifest (success, error) {
+            requestFile('/AppxManifest.xml', function (contents) {
+                success(new Manifest(contents));
+            }, error);
+        }
 
-// Event to indicate the Cordova native side is ready.
-channel.createSticky('onNativeReady');
+        /**
+         * Reads a preference value from config.xml.
+         * Returns preference value or undefined if it does not exist.
+         * @param {String} preferenceName Preference name to read */
+        Config.prototype.getPreferenceValue = function (preferenceName) {
+            var preferenceItem = this.preferences && this.preferences.filter(function (item) {
+                return item.attributes['name'].value === preferenceName;
+            });
+
+            if (preferenceItem && preferenceItem[0] && preferenceItem[0].attributes && preferenceItem[0].attributes['value']) {
+                return preferenceItem[0].attributes['value'].value;
+            }
+        };
 
-// Event to indicate that all Cordova JavaScript objects have been created
-// and it's time to run plugin constructors.
-channel.createSticky('onCordovaReady');
+        /**
+         * Reads SplashScreen image path
+         */
+        Manifest.prototype.getSplashScreenImagePath = function () {
+            return this.splashScreen.attributes['Image'].value;
+        };
 
-// Event to indicate that all automatically loaded JS plugins are loaded and ready.
-// FIXME remove this
-channel.createSticky('onPluginsReady');
+        exports.readConfig = readConfig;
+        exports.readManifest = readManifest;
 
-// Event to indicate that Cordova is ready
-channel.createSticky('onDeviceReady');
+    });
 
-// Event to indicate a resume lifecycle event
-channel.create('onResume');
+    // file: f:/coho/cordova-windows/cordova-js-src/exec.js
+    define('cordova/exec', function (require, exports, module) {
 
-// Event to indicate a pause lifecycle event
-channel.create('onPause');
+    /* jslint sloppy:true, plusplus:true */
+    /* global require, module, console */
 
-// Channels that must fire before "deviceready" is fired.
-channel.waitForInitialization('onCordovaReady');
-channel.waitForInitialization('onDOMContentLoaded');
+        var cordova = require('cordova');
+        var execProxy = require('cordova/exec/proxy');
 
-module.exports = channel;
+        /**
+         * Execute a cordova command.  It is up to the native side whether this action
+         * is synchronous or asynchronous.  The native side can return:
+         *      Synchronous: PluginResult object as a JSON string
+         *      Asynchronous: Empty string ""
+         * If async, the native side will cordova.callbackSuccess or cordova.callbackError,
+         * depending upon the result of the action.
+         *
+         * @param {Function} success    The success callback
+         * @param {Function} fail       The fail callback
+         * @param {String} service      The name of the service to use
+         * @param {String} action       Action to be run in cordova
+         * @param {String[]} [args]     Zero or more arguments to pass to the method
+         */
+        module.exports = function (success, fail, service, action, args) {
+
+            // Handle the case when we have an old version of splashscreen plugin to avoid the API calls failures
+            if (service === 'SplashScreen') {
+                var pluginsVersions = require('cordova/plugin_list').metadata;
+                var splashscreenVersion = pluginsVersions['cordova-plugin-splashscreen'];
+                var MIN_SPLASHSCREEN_SUPPORTED_VER = 4;
+                if (splashscreenVersion && ((parseInt(splashscreenVersion.split('.')[0], 10) || 0) < MIN_SPLASHSCREEN_SUPPORTED_VER)) {
+                    console.log('Warning: A more recent version of cordova-plugin-splashscreen has been hooked into for compatibility reasons. Update the plugin to version >= 4.');
+
+                    var platformSplashscreen = require('cordova/splashscreen');
+                    // Replace old plugin proxy with the platform's one
+                    require('cordova/exec/proxy').add(service, platformSplashscreen);
+                }
+            }
 
-});
+            var proxy = execProxy.get(service, action);
+            var callbackId;
+            var onSuccess;
+            var onError;
 
-// file: f:/coho/cordova-windows/cordova-js-src/confighelper.js
-define("cordova/confighelper", function(require, exports, module) {
+            args = args || [];
 
-// config.xml and AppxManifest.xml wrapper (non-node ConfigParser analogue)
-var configCache = {};
-var utils = require("cordova/utils");
+            if (proxy) {
+                callbackId = service + cordova.callbackId++;
+                // console.log("EXEC:" + service + " : " + action);
+                if (typeof success === 'function' || typeof fail === 'function') {
+                    cordova.callbacks[callbackId] = {success: success, fail: fail};
+                }
+                try {
+                    // callbackOptions param represents additional optional parameters command could pass back, like keepCallback or
+                    // custom callbackId, for example {callbackId: id, keepCallback: true, status: cordova.callbackStatus.JSON_EXCEPTION }
+                    // CB-5806 [Windows8] Add keepCallback support to proxy
+                    onSuccess = function (result, callbackOptions) {
+                        callbackOptions = callbackOptions || {};
+                        var callbackStatus;
+                        // covering both undefined and null.
+                        // strict null comparison was causing callbackStatus to be undefined
+                        // and then no callback was called because of the check in cordova.callbackFromNative
+                        // see CB-8996 Mobilespec app hang on windows
+                        if (callbackOptions.status !== undefined && callbackOptions.status !== null) {
+                            callbackStatus = callbackOptions.status;
+                        } else {
+                            callbackStatus = cordova.callbackStatus.OK;
+                        }
+                        cordova.callbackSuccess(callbackOptions.callbackId || callbackId,
+                            {
+                                status: callbackStatus,
+                                message: result,
+                                keepCallback: callbackOptions.keepCallback || false
+                            });
+                    };
+                    onError = function (err, callbackOptions) {
+                        callbackOptions = callbackOptions || {};
+                        var callbackStatus;
+                        // covering both undefined and null.
+                        // strict null comparison was causing callbackStatus to be undefined
+                        // and then no callback was called because of the check in cordova.callbackFromNative
+                        // see CB-8996 Mobilespec app hang on windows
+                        if (callbackOptions.status !== undefined && callbackOptions.status !== null) {
+                            callbackStatus = callbackOptions.status;
+                        } else {
+                            callbackStatus = cordova.callbackStatus.OK;
+                        }
+                        cordova.callbackError(callbackOptions.callbackId || callbackId,
+                            {
+                                status: callbackStatus,
+                                message: err,
+                                keepCallback: callbackOptions.keepCallback || false
+                            });
+                    };
+                    proxy(onSuccess, onError, args);
+
+                } catch (e) {
+                    console.log('Exception calling native with command :: ' + service + ' :: ' + action + ' ::exception=' + e);
+                }
+            } else {
+                if (typeof fail === 'function') {
+                    fail('Missing Command Error');
+                }
+            }
+        };
 
-var isPhone = (cordova.platformId == 'windows') && WinJS.Utilities.isPhone;
-var isWin10UWP = navigator.appVersion.indexOf('MSAppHost/3.0') !== -1;
-var splashScreenTagName = isWin10UWP ? "SplashScreen" : (isPhone ? "m3:SplashScreen" : "m2:SplashScreen");
+    });
 
-function XmlFile(text) {
-    this.text = text;
-}
+    // file: src/common/exec/proxy.js
+    define('cordova/exec/proxy', function (require, exports, module) {
 
-XmlFile.prototype.loadTags = function (tagName) {
-    var parser;
-    if (!this.doc) {
-        parser = new DOMParser();
-        this.doc = parser.parseFromString(this.text, "application/xml");
-    }
+        // internal map of proxy function
+        var CommandProxyMap = {};
 
-    var tags = this.doc.getElementsByTagName(tagName);
-    return Array.prototype.slice.call(tags);
-}
+        module.exports = {
 
-function Config(text) {
-    XmlFile.apply(this, arguments);
-    this.preferences = this.loadTags("preference");
-}
+            // 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;
+            },
 
-function Manifest(text) {
-    XmlFile.apply(this, arguments);
-    this.splashScreen = this.loadTags(splashScreenTagName)[0];
-}
+            // cordova.commandProxy.remove("Accelerometer");
+            remove: function (id) {
+                var proxy = CommandProxyMap[id];
+                delete CommandProxyMap[id];
+                CommandProxyMap[id] = null;
+                return proxy;
+            },
 
-utils.extend(Config, XmlFile);
-utils.extend(Manifest, XmlFile);
+            get: function (service, action) {
+                return (CommandProxyMap[service] ? CommandProxyMap[service][action] : null);
+            }
+        };
+    });
 
-function requestFile(filePath, success, error) {
-    var xhr;
+    // file: src/common/init.js
+    define('cordova/init', function (require, exports, module) {
 
-    if (typeof configCache[filePath] != 'undefined') {
-        success(configCache[filePath]);
-    }
+        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');
 
-    function fail(msg) {
-        console.error(msg);
+        var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady];
 
-        if (error) {
-            error(msg);
+        function logUnfiredChannels (arr) {
+            for (var i = 0; i < arr.length; ++i) {
+                if (arr[i].state !== 2) {
+                    console.log('Channel not fired: ' + arr[i].type);
+                }
+            }
         }
-    }
 
-    var xhrStatusChangeHandler = function () {
-        if (xhr.readyState == 4) {
-            if (xhr.status == 200 || xhr.status == 304 || xhr.status == 0 /* file:// */) {
-                configCache[filePath] = xhr.responseText;
-                success(xhr.responseText);
+        window.setTimeout(function () {
+            if (channel.onDeviceReady.state !== 2) {
+                console.log('deviceready has not fired after 5 seconds.');
+                logUnfiredChannels(platformInitChannelsArray);
+                logUnfiredChannels(channel.deviceReadyChannelsArray);
             }
-            else {
-                fail('[Windows][cordova.js][xhrStatusChangeHandler] Could not XHR ' + filePath + ': ' + xhr.statusText);
+        }, 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;
         }
-    };
-
-    xhr = new XMLHttpRequest();
-    xhr.addEventListener("load", xhrStatusChangeHandler);
 
-    try {
-        xhr.open("get", filePath, true);
-        xhr.send();
-    } catch (e) {
-        fail('[Windows][cordova.js][xhrFile] Could not XHR ' + filePath + ': ' + JSON.stringify(e));
-    }
-}
-
-function readConfig(success, error) {
-    requestFile("/config.xml", function (contents) {
-        success(new Config(contents));
-    }, error);
-}
-
-function readManifest(success, error) {
-    requestFile("/AppxManifest.xml", function (contents) {
-        success(new Manifest(contents));
-    }, error);
-}
-
-/**
- * Reads a preference value from config.xml.
- * Returns preference value or undefined if it does not exist.
- * @param {String} preferenceName Preference name to read */
-Config.prototype.getPreferenceValue = function (preferenceName) {
-    var preferenceItem = this.preferences && this.preferences.filter(function (item) {
-        return item.attributes['name'].value === preferenceName;
-    });
+        if (window.navigator) {
+            window.navigator = replaceNavigator(window.navigator);
+        }
 
-    if (preferenceItem && preferenceItem[0] && preferenceItem[0].attributes && preferenceItem[0].attributes['value']) {
-        return preferenceItem[0].attributes['value'].value;
-    }
-}
-
-/**
- * Reads SplashScreen image path
- */
-Manifest.prototype.getSplashScreenImagePath = function () {
-    return this.splashScreen.attributes['Image'].value;
-}
-
-exports.readConfig = readConfig;
-exports.readManifest = readManifest;
-
-});
-
-// file: f:/coho/cordova-windows/cordova-js-src/exec.js
-define("cordova/exec", function(require, exports, module) {
-
-/*jslint sloppy:true, plusplus:true*/
-/*global require, module, console */
-
-var cordova = require('cordova');
-var execProxy = require('cordova/exec/proxy');
-
-/**
- * Execute a cordova command.  It is up to the native side whether this action
- * is synchronous or asynchronous.  The native side can return:
- *      Synchronous: PluginResult object as a JSON string
- *      Asynchronous: Empty string ""
- * If async, the native side will cordova.callbackSuccess or cordova.callbackError,
- * depending upon the result of the action.
- *
- * @param {Function} success    The success callback
- * @param {Function} fail       The fail callback
- * @param {String} service      The name of the service to use
- * @param {String} action       Action to be run in cordova
- * @param {String[]} [args]     Zero or more arguments to pass to the method
- */
-module.exports = function (success, fail, service, action, args) {
-
-    // Handle the case when we have an old version of splashscreen plugin to avoid the API calls failures
-    if (service === 'SplashScreen') {
-        var pluginsVersions = require("cordova/plugin_list").metadata;
-        var splashscreenVersion = pluginsVersions['cordova-plugin-splashscreen'];
-        var MIN_SPLASHSCREEN_SUPPORTED_VER = 4;
-        if (splashscreenVersion && ((parseInt(splashscreenVersion.split('.')[0], 10) || 0) < MIN_SPLASHSCREEN_SUPPORTED_VER)) {
-            console.log('Warning: A more recent version of cordova-plugin-splashscreen has been hooked into for compatibility reasons. Update the plugin to version >= 4.');
-
-            var platformSplashscreen = require('cordova/splashscreen');
-            // Replace old plugin proxy with the platform's one
-            require('cordova/exec/proxy').add(service, platformSplashscreen);
+        if (!window.console) {
+            window.console = {
+                log: function () {}
+            };
+        }
+        if (!window.console.warn) {
+            window.console.warn = function (msg) {
+                this.log('warn: ' + msg);
+            };
         }
-    }
 
-    var proxy = execProxy.get(service, action),
-        callbackId,
-        onSuccess,
-        onError;
+        // Register pause, resume and deviceready channels as events on document.
+        channel.onPause = cordova.addDocumentEventHandler('pause');
+        channel.onResume = cordova.addDocumentEventHandler('resume');
+        channel.onActivated = cordova.addDocumentEventHandler('activated');
+        channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
 
-    args = args || [];
+        // 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);
+        }
 
-    if (proxy) {
-        callbackId = service + cordova.callbackId++;
-        // console.log("EXEC:" + service + " : " + action);
-        if (typeof success === "function" || typeof fail === "function") {
-            cordova.callbacks[callbackId] = {success: success, fail: fail};
+        // _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();
         }
-        try {
-            // callbackOptions param represents additional optional parameters command could pass back, like keepCallback or
-            // custom callbackId, for example {callbackId: id, keepCallback: true, status: cordova.callbackStatus.JSON_EXCEPTION }
-            // CB-5806 [Windows8] Add keepCallback support to proxy
-            onSuccess = function (result, callbackOptions) {
-                callbackOptions = callbackOptions || {};
-                var callbackStatus;
-                // covering both undefined and null.
-                // strict null comparison was causing callbackStatus to be undefined
-                // and then no callback was called because of the check in cordova.callbackFromNative
-                // see CB-8996 Mobilespec app hang on windows
-                if (callbackOptions.status !== undefined && callbackOptions.status !== null) {
-                    callbackStatus = callbackOptions.status;
+
+        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 modulemapper = require('cordova/modulemapper');
+        var platform = require('cordova/platform');
+        var pluginloader = require('cordova/pluginloader');
+        var utils = require('cordova/utils');
+
+        var platformInitChannelsArray = [channel.onDOMContentLoaded, channel.onNativeReady, channel.onPluginsReady];
+
+        // 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);
                 }
-                else {
-                    callbackStatus = cordova.callbackStatus.OK;
+            }
+        }
+
+        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);
+                    }
                 }
-                cordova.callbackSuccess(callbackOptions.callbackId || callbackId,
-                    {
-                        status: callbackStatus,
-                        message: result,
-                        keepCallback: callbackOptions.keepCallback || false
-                    });
+            }
+            return newNavigator;
+        }
+        if (window.navigator) {
+            window.navigator = replaceNavigator(window.navigator);
+        }
+
+        if (!window.console) {
+            window.console = {
+                log: function () {}
             };
-            onError = function (err, callbackOptions) {
-                callbackOptions = callbackOptions || {};
-                var callbackStatus;
-                // covering both undefined and null.
-                // strict null comparison was causing callbackStatus to be undefined
-                // and then no callback was called because of the check in cordova.callbackFromNative
-                // see CB-8996 Mobilespec app hang on windows
-                if (callbackOptions.status !== undefined && callbackOptions.status !== null) {
-                    callbackStatus = callbackOptions.status;
-                }
-                else {
-                    callbackStatus = cordova.callbackStatus.OK;
-                }
-                cordova.callbackError(callbackOptions.callbackId || callbackId,
-                    {
-                        status: callbackStatus,
-                        message: err,
-                        keepCallback: callbackOptions.keepCallback || false
-                    });
+        }
+        if (!window.console.warn) {
+            window.console.warn = function (msg) {
+                this.log('warn: ' + msg);
             };
-            proxy(onSuccess, onError, args);
-
-        } catch (e) {
-            console.log("Exception calling native with command :: " + service + " :: " + action  + " ::exception=" + e);
         }
-    } else {
-        if (typeof fail === "function") {
-            fail("Missing Command Error");
+
+        // Register pause, resume and deviceready channels as events on document.
+        channel.onPause = cordova.addDocumentEventHandler('pause');
+        channel.onResume = cordova.addDocumentEventHandler('resume');
+        channel.onActivated = cordova.addDocumentEventHandler('activated');
+        channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
+
+        // Listen for DOMContentLoaded and notify our channel subscribers.
+        if (document.readyState === 'complete' || document.readyState === 'interactive') {
+            ch

<TRUNCATED>

---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message