{"version":3,"sources":["ocLazyLoad.js"],"names":["angular","window","regModules","regInvokes","regConfigs","modulesToLoad","recordDeclarations","broadcast","noop","runBlocks","justLoaded","ocLazyLoad","module","provider","$controllerProvider","$provide","$compileProvider","$filterProvider","$injector","$animateProvider","_register","providers","registerModules","params","k","moduleName","moduleFn","tempRunBlocks","length","isString","getModuleName","indexOf","newModule","ngModuleFct","push","requires","_runBlocks","shift","isDefined","rerun","concat","_invokeQueue","reconfig","_configBlocks","pop","instanceInjector","getInstanceInjector","forEach","fn","invoke","_registerInvokeList","args","signature","data","isArray","hashCode","toString","isObject","stringify","invokeList","type","newInvoke","isUndefined","onInvoke","invokeName","hasOwnProperty","key","queue","i","len","Error","isNew","apply","callInvoke","fct","invoked","isFunction","j","jlen","name","moduleExists","e","test","message","modules","debug","events","moduleCache","value","this","Array","prototype","arguments","config","moduleConfig","_init","element","elements","names","NG_APP_CLASS_REGEXP","append","elm","document","getElementById","replace","querySelectorAll","className","match","exec","attributes","attr","jasmine","mocha","mock","console","error","addReg","mainModule","obj","cache","JSON","str","chr","hash","charCodeAt","$get","$log","$rootElement","$rootScope","$cacheFactory","$q","reject","deferred","defer","promise","filesCache","injector","eventName","$broadcast","info","_broadcast","_$log","_getFilesCache","toggleWatch","watch","getModuleConfig","copy","setModuleConfig","getModules","isLoaded","modulesNames","moduleLoaded","_getModuleName","_getModule","_loadDependencies","localParams","loadedModule","diff","promisesList","self","when","getRequires","requireEntry","files","filter","n","warn","filesLoader","then","all","inject","undefined","_addToLoadList","res","slice","loadNext","resolve","err","requireModule","bootstrapFct","bootstrap","force","configFn","exports","directive","$ocLazyLoad","$compile","$animate","$parse","restrict","terminal","priority","compile","attrs","content","innerHTML","html","$scope","$element","$attr","model","$watch","load","enter","contents","nodeType","decorator","$delegate","$window","$interval","uaCssChecked","useCssLoadPatch","anchor","getElementsByTagName","buildElement","path","el","loaded","cacheBuster","url","dc","Date","getTime","substring","get","put","createElement","rel","href","src","remove","onload","onerror","async","serie","insertBeforeElem","lastChild","insertBefore","jQuery","querySelector","parentNode","ua","navigator","userAgent","toLowerCase","platform","v","appVersion","iOSVersion","parseFloat","parseInt","join","androidVersion","versionMatch","tries","interval","sheet","cssRules","cancel","cssFiles","templatesFiles","jsFiles","promises","cachePromise","extend","pushFile","m","file_type","substr","jsLoader","cssDeferred","cssLoader","templatesDeferred","templatesLoader","jsDeferred","originalModule","errText","originalParams","deferredList","template","paths","callback","ocLazyLoadLoader","$templateCache","$http","success","node","nodeName","id","searchElement","fromIndex","TypeError","O","Object","Math","abs","Infinity","max"],"mappings":"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","file":"ocLazyLoad.min.js","sourcesContent":["/**\n * oclazyload - Load modules on demand (lazy load) with angularJS\n * @version v1.0.1\n * @link https://github.com/ocombe/ocLazyLoad\n * @license MIT\n * @author Olivier Combe <olivier.combe@gmail.com>\n */\n(function (angular, window) {\n    'use strict';\n\n    var regModules = ['ng', 'oc.lazyLoad'],\n        regInvokes = {},\n        regConfigs = [],\n        modulesToLoad = [],\n        recordDeclarations = [],\n        broadcast = angular.noop,\n        runBlocks = {},\n        justLoaded = [];\n\n    var ocLazyLoad = angular.module('oc.lazyLoad', ['ng']);\n\n    ocLazyLoad.provider('$ocLazyLoad', [\"$controllerProvider\", \"$provide\", \"$compileProvider\", \"$filterProvider\", \"$injector\", \"$animateProvider\", function ($controllerProvider, $provide, $compileProvider, $filterProvider, $injector, $animateProvider) {\n        var modules = {},\n            providers = {\n            $controllerProvider: $controllerProvider,\n            $compileProvider: $compileProvider,\n            $filterProvider: $filterProvider,\n            $provide: $provide, // other things (constant, decorator, provider, factory, service)\n            $injector: $injector,\n            $animateProvider: $animateProvider\n        },\n            debug = false,\n            events = false,\n            moduleCache = [];\n\n        moduleCache.push = function (value) {\n            if (this.indexOf(value) === -1) {\n                Array.prototype.push.apply(this, arguments);\n            }\n        };\n\n        this.config = function (config) {\n            // If we want to define modules configs\n            if (angular.isDefined(config.modules)) {\n                if (angular.isArray(config.modules)) {\n                    angular.forEach(config.modules, function (moduleConfig) {\n                        modules[moduleConfig.name] = moduleConfig;\n                    });\n                } else {\n                    modules[config.modules.name] = config.modules;\n                }\n            }\n\n            if (angular.isDefined(config.debug)) {\n                debug = config.debug;\n            }\n\n            if (angular.isDefined(config.events)) {\n                events = config.events;\n            }\n        };\n\n        /**\r\n         * Get the list of existing registered modules\r\n         * @param element\r\n         */\n        this._init = function _init(element) {\n            // this is probably useless now because we override angular.bootstrap\n            if (modulesToLoad.length === 0) {\n                var elements = [element],\n                    names = ['ng:app', 'ng-app', 'x-ng-app', 'data-ng-app'],\n                    NG_APP_CLASS_REGEXP = /\\sng[:\\-]app(:\\s*([\\w\\d_]+);?)?\\s/,\n                    append = function append(elm) {\n                    return elm && elements.push(elm);\n                };\n\n                angular.forEach(names, function (name) {\n                    names[name] = true;\n                    append(document.getElementById(name));\n                    name = name.replace(':', '\\\\:');\n                    if (element[0].querySelectorAll) {\n                        angular.forEach(element[0].querySelectorAll('.' + name), append);\n                        angular.forEach(element[0].querySelectorAll('.' + name + '\\\\:'), append);\n                        angular.forEach(element[0].querySelectorAll('[' + name + ']'), append);\n                    }\n                });\n\n                angular.forEach(elements, function (elm) {\n                    if (modulesToLoad.length === 0) {\n                        var className = ' ' + element.className + ' ';\n                        var match = NG_APP_CLASS_REGEXP.exec(className);\n                        if (match) {\n                            modulesToLoad.push((match[2] || '').replace(/\\s+/g, ','));\n                        } else {\n                            angular.forEach(elm.attributes, function (attr) {\n                                if (modulesToLoad.length === 0 && names[attr.name]) {\n                                    modulesToLoad.push(attr.value);\n                                }\n                            });\n                        }\n                    }\n                });\n            }\n\n            if (modulesToLoad.length === 0 && !((window.jasmine || window.mocha) && angular.isDefined(angular.mock))) {\n                console.error('No module found during bootstrap, unable to init ocLazyLoad. You should always use the ng-app directive or angular.boostrap when you use ocLazyLoad.');\n            }\n\n            var addReg = function addReg(moduleName) {\n                if (regModules.indexOf(moduleName) === -1) {\n                    // register existing modules\n                    regModules.push(moduleName);\n                    var mainModule = angular.module(moduleName);\n\n                    // register existing components (directives, services, ...)\n                    _invokeQueue(null, mainModule._invokeQueue, moduleName);\n                    _invokeQueue(null, mainModule._configBlocks, moduleName); // angular 1.3+\n\n                    angular.forEach(mainModule.requires, addReg);\n                }\n            };\n\n            angular.forEach(modulesToLoad, function (moduleName) {\n                addReg(moduleName);\n            });\n\n            modulesToLoad = []; // reset for next bootstrap\n            recordDeclarations.pop(); // wait for the next lazy load\n        };\n\n        /**\r\n         * Like JSON.stringify but that doesn't throw on circular references\r\n         * @param obj\r\n         */\n        var stringify = function stringify(obj) {\n            var cache = [];\n            return JSON.stringify(obj, function (key, value) {\n                if (angular.isObject(value) && value !== null) {\n                    if (cache.indexOf(value) !== -1) {\n                        // Circular reference found, discard key\n                        return;\n                    }\n                    // Store value in our collection\n                    cache.push(value);\n                }\n                return value;\n            });\n        };\n\n        var hashCode = function hashCode(str) {\n            var hash = 0,\n                i,\n                chr,\n                len;\n            if (str.length == 0) {\n                return hash;\n            }\n            for (i = 0, len = str.length; i < len; i++) {\n                chr = str.charCodeAt(i);\n                hash = (hash << 5) - hash + chr;\n                hash |= 0; // Convert to 32bit integer\n            }\n            return hash;\n        };\n\n        function _register(providers, registerModules, params) {\n            if (registerModules) {\n                var k,\n                    moduleName,\n                    moduleFn,\n                    tempRunBlocks = [];\n                for (k = registerModules.length - 1; k >= 0; k--) {\n                    moduleName = registerModules[k];\n                    if (!angular.isString(moduleName)) {\n                        moduleName = getModuleName(moduleName);\n                    }\n                    if (!moduleName || justLoaded.indexOf(moduleName) !== -1) {\n                        continue;\n                    }\n                    var newModule = regModules.indexOf(moduleName) === -1;\n                    moduleFn = ngModuleFct(moduleName);\n                    if (newModule) {\n                        // new module\n                        regModules.push(moduleName);\n                        _register(providers, moduleFn.requires, params);\n                    }\n                    if (moduleFn._runBlocks.length > 0) {\n                        // new run blocks detected! Replace the old ones (if existing)\n                        runBlocks[moduleName] = [];\n                        while (moduleFn._runBlocks.length > 0) {\n                            runBlocks[moduleName].push(moduleFn._runBlocks.shift());\n                        }\n                    }\n                    if (angular.isDefined(runBlocks[moduleName]) && (newModule || params.rerun)) {\n                        tempRunBlocks = tempRunBlocks.concat(runBlocks[moduleName]);\n                    }\n                    _invokeQueue(providers, moduleFn._invokeQueue, moduleName, params.reconfig);\n                    _invokeQueue(providers, moduleFn._configBlocks, moduleName, params.reconfig); // angular 1.3+\n                    broadcast(newModule ? 'ocLazyLoad.moduleLoaded' : 'ocLazyLoad.moduleReloaded', moduleName);\n                    registerModules.pop();\n                    justLoaded.push(moduleName);\n                }\n                // execute the run blocks at the end\n                var instanceInjector = providers.getInstanceInjector();\n                angular.forEach(tempRunBlocks, function (fn) {\n                    instanceInjector.invoke(fn);\n                });\n            }\n        }\n\n        function _registerInvokeList(args, moduleName) {\n            var invokeList = args[2][0],\n                type = args[1],\n                newInvoke = false;\n            if (angular.isUndefined(regInvokes[moduleName])) {\n                regInvokes[moduleName] = {};\n            }\n            if (angular.isUndefined(regInvokes[moduleName][type])) {\n                regInvokes[moduleName][type] = {};\n            }\n            var onInvoke = function onInvoke(invokeName, signature) {\n                if (!regInvokes[moduleName][type].hasOwnProperty(invokeName)) {\n                    regInvokes[moduleName][type][invokeName] = [];\n                }\n                if (regInvokes[moduleName][type][invokeName].indexOf(signature) === -1) {\n                    newInvoke = true;\n                    regInvokes[moduleName][type][invokeName].push(signature);\n                    broadcast('ocLazyLoad.componentLoaded', [moduleName, type, invokeName]);\n                }\n            };\n\n            function signature(data) {\n                if (angular.isArray(data)) {\n                    // arrays are objects, we need to test for it first\n                    return hashCode(data.toString());\n                } else if (angular.isObject(data)) {\n                    // constants & values for example\n                    return hashCode(stringify(data));\n                } else {\n                    if (angular.isDefined(data) && data !== null) {\n                        return hashCode(data.toString());\n                    } else {\n                        // null & undefined constants\n                        return data;\n                    }\n                }\n            }\n\n            if (angular.isString(invokeList)) {\n                onInvoke(invokeList, signature(args[2][1]));\n            } else if (angular.isObject(invokeList)) {\n                angular.forEach(invokeList, function (invoke, key) {\n                    if (angular.isString(invoke)) {\n                        // decorators for example\n                        onInvoke(invoke, signature(invokeList[1]));\n                    } else {\n                        // components registered as object lists {\"componentName\": function() {}}\n                        onInvoke(key, signature(invoke));\n                    }\n                });\n            } else {\n                return false;\n            }\n            return newInvoke;\n        }\n\n        function _invokeQueue(providers, queue, moduleName, reconfig) {\n            if (!queue) {\n                return;\n            }\n\n            var i, len, args, provider;\n            for (i = 0, len = queue.length; i < len; i++) {\n                args = queue[i];\n                if (angular.isArray(args)) {\n                    if (providers !== null) {\n                        if (providers.hasOwnProperty(args[0])) {\n                            provider = providers[args[0]];\n                        } else {\n                            throw new Error('unsupported provider ' + args[0]);\n                        }\n                    }\n                    var isNew = _registerInvokeList(args, moduleName);\n                    if (args[1] !== 'invoke') {\n                        if (isNew && angular.isDefined(provider)) {\n                            provider[args[1]].apply(provider, args[2]);\n                        }\n                    } else {\n                        // config block\n                        var callInvoke = function callInvoke(fct) {\n                            var invoked = regConfigs.indexOf('' + moduleName + '-' + fct);\n                            if (invoked === -1 || reconfig) {\n                                if (invoked === -1) {\n                                    regConfigs.push('' + moduleName + '-' + fct);\n                                }\n                                if (angular.isDefined(provider)) {\n                                    provider[args[1]].apply(provider, args[2]);\n                                }\n                            }\n                        };\n                        if (angular.isFunction(args[2][0])) {\n                            callInvoke(args[2][0]);\n                        } else if (angular.isArray(args[2][0])) {\n                            for (var j = 0, jlen = args[2][0].length; j < jlen; j++) {\n                                if (angular.isFunction(args[2][0][j])) {\n                                    callInvoke(args[2][0][j]);\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        function getModuleName(module) {\n            var moduleName = null;\n            if (angular.isString(module)) {\n                moduleName = module;\n            } else if (angular.isObject(module) && module.hasOwnProperty('name') && angular.isString(module.name)) {\n                moduleName = module.name;\n            }\n            return moduleName;\n        }\n\n        function moduleExists(moduleName) {\n            if (!angular.isString(moduleName)) {\n                return false;\n            }\n            try {\n                return ngModuleFct(moduleName);\n            } catch (e) {\n                if (/No module/.test(e) || e.message.indexOf('$injector:nomod') > -1) {\n                    return false;\n                }\n            }\n        }\n\n        this.$get = [\"$log\", \"$rootElement\", \"$rootScope\", \"$cacheFactory\", \"$q\", function ($log, $rootElement, $rootScope, $cacheFactory, $q) {\n            var instanceInjector,\n                filesCache = $cacheFactory('ocLazyLoad');\n\n            if (!debug) {\n                $log = {};\n                $log['error'] = angular.noop;\n                $log['warn'] = angular.noop;\n                $log['info'] = angular.noop;\n            }\n\n            // Make this lazy because when $get() is called the instance injector hasn't been assigned to the rootElement yet\n            providers.getInstanceInjector = function () {\n                return instanceInjector ? instanceInjector : instanceInjector = $rootElement.data('$injector') || angular.injector();\n            };\n\n            broadcast = function broadcast(eventName, params) {\n                if (events) {\n                    $rootScope.$broadcast(eventName, params);\n                }\n                if (debug) {\n                    $log.info(eventName, params);\n                }\n            };\n\n            function reject(e) {\n                var deferred = $q.defer();\n                $log.error(e.message);\n                deferred.reject(e);\n                return deferred.promise;\n            }\n\n            return {\n                _broadcast: broadcast,\n\n                _$log: $log,\n\n                /**\r\n                 * Returns the files cache used by the loaders to store the files currently loading\r\n                 * @returns {*}\r\n                 */\n                _getFilesCache: function getFilesCache() {\n                    return filesCache;\n                },\n\n                /**\r\n                 * Let the service know that it should monitor angular.module because files are loading\r\n                 * @param watch boolean\r\n                 */\n                toggleWatch: function toggleWatch(watch) {\n                    if (watch) {\n                        recordDeclarations.push(true);\n                    } else {\n                        recordDeclarations.pop();\n                    }\n                },\n\n                /**\r\n                 * Let you get a module config object\r\n                 * @param moduleName String the name of the module\r\n                 * @returns {*}\r\n                 */\n                getModuleConfig: function getModuleConfig(moduleName) {\n                    if (!angular.isString(moduleName)) {\n                        throw new Error('You need to give the name of the module to get');\n                    }\n                    if (!modules[moduleName]) {\n                        return null;\n                    }\n                    return angular.copy(modules[moduleName]);\n                },\n\n                /**\r\n                 * Let you define a module config object\r\n                 * @param moduleConfig Object the module config object\r\n                 * @returns {*}\r\n                 */\n                setModuleConfig: function setModuleConfig(moduleConfig) {\n                    if (!angular.isObject(moduleConfig)) {\n                        throw new Error('You need to give the module config object to set');\n                    }\n                    modules[moduleConfig.name] = moduleConfig;\n                    return moduleConfig;\n                },\n\n                /**\r\n                 * Returns the list of loaded modules\r\n                 * @returns {string[]}\r\n                 */\n                getModules: function getModules() {\n                    return regModules;\n                },\n\n                /**\r\n                 * Let you check if a module has been loaded into Angular or not\r\n                 * @param modulesNames String/Object a module name, or a list of module names\r\n                 * @returns {boolean}\r\n                 */\n                isLoaded: function isLoaded(modulesNames) {\n                    var moduleLoaded = function moduleLoaded(module) {\n                        var isLoaded = regModules.indexOf(module) > -1;\n                        if (!isLoaded) {\n                            isLoaded = !!moduleExists(module);\n                        }\n                        return isLoaded;\n                    };\n                    if (angular.isString(modulesNames)) {\n                        modulesNames = [modulesNames];\n                    }\n                    if (angular.isArray(modulesNames)) {\n                        var i, len;\n                        for (i = 0, len = modulesNames.length; i < len; i++) {\n                            if (!moduleLoaded(modulesNames[i])) {\n                                return false;\n                            }\n                        }\n                        return true;\n                    } else {\n                        throw new Error('You need to define the module(s) name(s)');\n                    }\n                },\n\n                /**\r\n                 * Given a module, return its name\r\n                 * @param module\r\n                 * @returns {String}\r\n                 */\n                _getModuleName: getModuleName,\n\n                /**\r\n                 * Returns a module if it exists\r\n                 * @param moduleName\r\n                 * @returns {module}\r\n                 */\n                _getModule: function getModule(moduleName) {\n                    try {\n                        return ngModuleFct(moduleName);\n                    } catch (e) {\n                        // this error message really suxx\n                        if (/No module/.test(e) || e.message.indexOf('$injector:nomod') > -1) {\n                            e.message = 'The module \"' + stringify(moduleName) + '\" that you are trying to load does not exist. ' + e.message;\n                        }\n                        throw e;\n                    }\n                },\n\n                /**\r\n                 * Check if a module exists and returns it if it does\r\n                 * @param moduleName\r\n                 * @returns {boolean}\r\n                 */\n                moduleExists: moduleExists,\n\n                /**\r\n                 * Load the dependencies, and might try to load new files depending on the config\r\n                 * @param moduleName (String or Array of Strings)\r\n                 * @param localParams\r\n                 * @returns {*}\r\n                 * @private\r\n                 */\n                _loadDependencies: function _loadDependencies(moduleName, localParams) {\n                    var loadedModule,\n                        requires,\n                        diff,\n                        promisesList = [],\n                        self = this;\n\n                    moduleName = self._getModuleName(moduleName);\n\n                    if (moduleName === null) {\n                        return $q.when();\n                    } else {\n                        try {\n                            loadedModule = self._getModule(moduleName);\n                        } catch (e) {\n                            return reject(e);\n                        }\n                        // get unloaded requires\n                        requires = self.getRequires(loadedModule);\n                    }\n\n                    angular.forEach(requires, function (requireEntry) {\n                        // If no configuration is provided, try and find one from a previous load.\n                        // If there isn't one, bail and let the normal flow run\n                        if (angular.isString(requireEntry)) {\n                            var config = self.getModuleConfig(requireEntry);\n                            if (config === null) {\n                                moduleCache.push(requireEntry); // We don't know about this module, but something else might, so push it anyway.\n                                return;\n                            }\n                            requireEntry = config;\n                        }\n\n                        // Check if this dependency has been loaded previously\n                        if (self.moduleExists(requireEntry.name)) {\n                            // compare against the already loaded module to see if the new definition adds any new files\n                            diff = requireEntry.files.filter(function (n) {\n                                return self.getModuleConfig(requireEntry.name).files.indexOf(n) < 0;\n                            });\n\n                            // If the module was redefined, advise via the console\n                            if (diff.length !== 0) {\n                                self._$log.warn('Module \"', moduleName, '\" attempted to redefine configuration for dependency. \"', requireEntry.name, '\"\\n Additional Files Loaded:', diff);\n                            }\n\n                            // Push everything to the file loader, it will weed out the duplicates.\n                            if (angular.isDefined(self.filesLoader)) {\n                                // if a files loader is defined\n                                promisesList.push(self.filesLoader(requireEntry, localParams).then(function () {\n                                    return self._loadDependencies(requireEntry);\n                                }));\n                            } else {\n                                return reject(new Error('Error: New dependencies need to be loaded from external files (' + requireEntry.files + '), but no loader has been defined.'));\n                            }\n                            return;\n                        } else if (angular.isArray(requireEntry)) {\n                            requireEntry = {\n                                files: requireEntry\n                            };\n                        } else if (angular.isObject(requireEntry)) {\n                            if (requireEntry.hasOwnProperty('name') && requireEntry['name']) {\n                                // The dependency doesn't exist in the module cache and is a new configuration, so store and push it.\n                                self.setModuleConfig(requireEntry);\n                                moduleCache.push(requireEntry['name']);\n                            }\n                        }\n\n                        // Check if the dependency has any files that need to be loaded. If there are, push a new promise to the promise list.\n                        if (angular.isDefined(requireEntry.files) && requireEntry.files.length !== 0) {\n                            if (angular.isDefined(self.filesLoader)) {\n                                // if a files loader is defined\n                                promisesList.push(self.filesLoader(requireEntry, localParams).then(function () {\n                                    return self._loadDependencies(requireEntry);\n                                }));\n                            } else {\n                                return reject(new Error('Error: the module \"' + requireEntry.name + '\" is defined in external files (' + requireEntry.files + '), but no loader has been defined.'));\n                            }\n                        }\n                    });\n\n                    // Create a wrapper promise to watch the promise list and resolve it once everything is done.\n                    return $q.all(promisesList);\n                },\n\n                /**\r\n                 * Inject new modules into Angular\r\n                 * @param moduleName\r\n                 * @param localParams\r\n                 */\n                inject: function inject(moduleName) {\n                    var localParams = arguments[1] === undefined ? {} : arguments[1];\n\n                    var self = this,\n                        deferred = $q.defer();\n                    if (angular.isDefined(moduleName) && moduleName !== null) {\n                        if (angular.isArray(moduleName)) {\n                            var promisesList = [];\n                            angular.forEach(moduleName, function (module) {\n                                promisesList.push(self.inject(module));\n                            });\n                            return $q.all(promisesList);\n                        } else {\n                            self._addToLoadList(self._getModuleName(moduleName), true);\n                        }\n                    }\n                    if (modulesToLoad.length > 0) {\n                        var res = modulesToLoad.slice(); // clean copy\n                        var loadNext = function loadNext(moduleName) {\n                            moduleCache.push(moduleName);\n                            self._loadDependencies(moduleName, localParams).then(function success() {\n                                try {\n                                    justLoaded = [];\n                                    _register(providers, moduleCache, localParams);\n                                } catch (e) {\n                                    self._$log.error(e.message);\n                                    deferred.reject(e);\n                                    return;\n                                }\n\n                                if (modulesToLoad.length > 0) {\n                                    loadNext(modulesToLoad.shift()); // load the next in list\n                                } else {\n                                    deferred.resolve(res); // everything has been loaded, resolve\n                                }\n                            }, function error(err) {\n                                deferred.reject(err);\n                            });\n                        };\n\n                        // load the first in list\n                        loadNext(modulesToLoad.shift());\n                    } else {\n                        deferred.resolve();\n                    }\n                    return deferred.promise;\n                },\n\n                /**\r\n                 * Get the list of required modules/services/... for this module\r\n                 * @param module\r\n                 * @returns {Array}\r\n                 */\n                getRequires: function getRequires(module) {\n                    var requires = [];\n                    angular.forEach(module.requires, function (requireModule) {\n                        if (regModules.indexOf(requireModule) === -1) {\n                            requires.push(requireModule);\n                        }\n                    });\n                    return requires;\n                },\n\n                /**\r\n                 * Invoke the new modules & component by their providers\r\n                 * @param providers\r\n                 * @param queue\r\n                 * @param moduleName\r\n                 * @param reconfig\r\n                 * @private\r\n                 */\n                _invokeQueue: _invokeQueue,\n\n                /**\r\n                 * Check if a module has been invoked and registers it if not\r\n                 * @param args\r\n                 * @param moduleName\r\n                 * @returns {boolean} is new\r\n                 */\n                _registerInvokeList: _registerInvokeList,\n\n                /**\r\n                 * Register a new module and loads it, executing the run/config blocks if needed\r\n                 * @param providers\r\n                 * @param registerModules\r\n                 * @param params\r\n                 * @private\r\n                 */\n                _register: _register,\n\n                /**\r\n                 * Add a module name to the list of modules that will be loaded in the next inject\r\n                 * @param name\r\n                 * @param force\r\n                 * @private\r\n                 */\n                _addToLoadList: _addToLoadList\n            };\n        }];\n\n        // Let's get the list of loaded modules & components\n        this._init(angular.element(window.document));\n    }]);\n\n    var bootstrapFct = angular.bootstrap;\n    angular.bootstrap = function (element, modules, config) {\n        // we use slice to make a clean copy\n        angular.forEach(modules.slice(), function (module) {\n            _addToLoadList(module, true);\n        });\n        return bootstrapFct(element, modules, config);\n    };\n\n    var _addToLoadList = function _addToLoadList(name, force) {\n        if ((recordDeclarations.length > 0 || force) && angular.isString(name) && modulesToLoad.indexOf(name) === -1) {\n            modulesToLoad.push(name);\n        }\n    };\n\n    var ngModuleFct = angular.module;\n    angular.module = function (name, requires, configFn) {\n        _addToLoadList(name);\n        return ngModuleFct(name, requires, configFn);\n    };\n\n    // CommonJS package manager support:\n    if (typeof module !== 'undefined' && typeof exports !== 'undefined' && module.exports === exports) {\n        module.exports = 'oc.lazyLoad';\n    }\n})(angular, window);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').directive('ocLazyLoad', [\"$ocLazyLoad\", \"$compile\", \"$animate\", \"$parse\", function ($ocLazyLoad, $compile, $animate, $parse) {\n        return {\n            restrict: 'A',\n            terminal: true,\n            priority: 1000,\n            compile: function compile(element, attrs) {\n                // we store the content and remove it before compilation\n                var content = element[0].innerHTML;\n                element.html('');\n\n                return function ($scope, $element, $attr) {\n                    var model = $parse($attr.ocLazyLoad);\n                    $scope.$watch(function () {\n                        return model($scope) || $attr.ocLazyLoad; // it can be a module name (string), an object, an array, or a scope reference to any of this\n                    }, function (moduleName) {\n                        if (angular.isDefined(moduleName)) {\n                            $ocLazyLoad.load(moduleName).then(function () {\n                                $animate.enter(content, $element);\n                                var contents = element.contents();\n                                angular.forEach(contents, function (content) {\n                                    if (content.nodeType !== 3) {\n                                        // 3 is a text node\n                                        $compile(content)($scope);\n                                    }\n                                });\n                            });\n                        }\n                    }, true);\n                };\n            }\n        };\n    }]);\n})(angular);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').config([\"$provide\", function ($provide) {\n        $provide.decorator('$ocLazyLoad', [\"$delegate\", \"$q\", \"$window\", \"$interval\", function ($delegate, $q, $window, $interval) {\n            var uaCssChecked = false,\n                useCssLoadPatch = false,\n                anchor = $window.document.getElementsByTagName('head')[0] || $window.document.getElementsByTagName('body')[0];\n\n            /**\n             * Load a js/css file\n             * @param type\n             * @param path\n             * @param params\n             * @returns promise\n             */\n            $delegate.buildElement = function buildElement(type, path, params) {\n                var deferred = $q.defer(),\n                    el,\n                    loaded,\n                    filesCache = $delegate._getFilesCache(),\n                    cacheBuster = function cacheBuster(url) {\n                    var dc = new Date().getTime();\n                    if (url.indexOf('?') >= 0) {\n                        if (url.substring(0, url.length - 1) === '&') {\n                            return '' + url + '_dc=' + dc;\n                        }\n                        return '' + url + '&_dc=' + dc;\n                    } else {\n                        return '' + url + '?_dc=' + dc;\n                    }\n                };\n\n                // Store the promise early so the file load can be detected by other parallel lazy loads\n                // (ie: multiple routes on one page) a 'true' value isn't sufficient\n                // as it causes false positive load results.\n                if (angular.isUndefined(filesCache.get(path))) {\n                    filesCache.put(path, deferred.promise);\n                }\n\n                // Switch in case more content types are added later\n                switch (type) {\n                    case 'css':\n                        el = $window.document.createElement('link');\n                        el.type = 'text/css';\n                        el.rel = 'stylesheet';\n                        el.href = params.cache === false ? cacheBuster(path) : path;\n                        break;\n                    case 'js':\n                        el = $window.document.createElement('script');\n                        el.src = params.cache === false ? cacheBuster(path) : path;\n                        break;\n                    default:\n                        filesCache.remove(path);\n                        deferred.reject(new Error('Requested type \"' + type + '\" is not known. Could not inject \"' + path + '\"'));\n                        break;\n                }\n                el.onload = el['onreadystatechange'] = function (e) {\n                    if (el['readyState'] && !/^c|loade/.test(el['readyState']) || loaded) return;\n                    el.onload = el['onreadystatechange'] = null;\n                    loaded = 1;\n                    $delegate._broadcast('ocLazyLoad.fileLoaded', path);\n                    deferred.resolve();\n                };\n                el.onerror = function () {\n                    filesCache.remove(path);\n                    deferred.reject(new Error('Unable to load ' + path));\n                };\n                el.async = params.serie ? 0 : 1;\n\n                var insertBeforeElem = anchor.lastChild;\n                if (params.insertBefore) {\n                    var element = angular.element(angular.isDefined(window.jQuery) ? params.insertBefore : document.querySelector(params.insertBefore));\n                    if (element && element.length > 0) {\n                        insertBeforeElem = element[0];\n                    }\n                }\n                insertBeforeElem.parentNode.insertBefore(el, insertBeforeElem);\n\n                /*\n                 The event load or readystatechange doesn't fire in:\n                 - iOS < 6       (default mobile browser)\n                 - Android < 4.4 (default mobile browser)\n                 - Safari < 6    (desktop browser)\n                 */\n                if (type == 'css') {\n                    if (!uaCssChecked) {\n                        var ua = $window.navigator.userAgent.toLowerCase();\n\n                        // iOS < 6\n                        if (/iP(hone|od|ad)/.test($window.navigator.platform)) {\n                            var v = $window.navigator.appVersion.match(/OS (\\d+)_(\\d+)_?(\\d+)?/);\n                            var iOSVersion = parseFloat([parseInt(v[1], 10), parseInt(v[2], 10), parseInt(v[3] || 0, 10)].join('.'));\n                            useCssLoadPatch = iOSVersion < 6;\n                        } else if (ua.indexOf('android') > -1) {\n                            // Android < 4.4\n                            var androidVersion = parseFloat(ua.slice(ua.indexOf('android') + 8));\n                            useCssLoadPatch = androidVersion < 4.4;\n                        } else if (ua.indexOf('safari') > -1) {\n                            var versionMatch = ua.match(/version\\/([\\.\\d]+)/i);\n                            useCssLoadPatch = versionMatch && versionMatch[1] && parseFloat(versionMatch[1]) < 6;\n                        }\n                    }\n\n                    if (useCssLoadPatch) {\n                        var tries = 1000; // * 20 = 20000 miliseconds\n                        var interval = $interval(function () {\n                            try {\n                                el.sheet.cssRules;\n                                $interval.cancel(interval);\n                                el.onload();\n                            } catch (e) {\n                                if (--tries <= 0) {\n                                    el.onerror();\n                                }\n                            }\n                        }, 20);\n                    }\n                }\n\n                return deferred.promise;\n            };\n\n            return $delegate;\n        }]);\n    }]);\n})(angular);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').config([\"$provide\", function ($provide) {\n        $provide.decorator('$ocLazyLoad', [\"$delegate\", \"$q\", function ($delegate, $q) {\n            /**\n             * The function that loads new files\n             * @param config\n             * @param params\n             * @returns {*}\n             */\n            $delegate.filesLoader = function filesLoader(config) {\n                var params = arguments[1] === undefined ? {} : arguments[1];\n\n                var cssFiles = [],\n                    templatesFiles = [],\n                    jsFiles = [],\n                    promises = [],\n                    cachePromise = null,\n                    filesCache = $delegate._getFilesCache();\n\n                $delegate.toggleWatch(true); // start watching angular.module calls\n\n                angular.extend(params, config);\n\n                var pushFile = function pushFile(path) {\n                    var file_type = null,\n                        m;\n                    if (angular.isObject(path)) {\n                        file_type = path.type;\n                        path = path.path;\n                    }\n                    cachePromise = filesCache.get(path);\n                    if (angular.isUndefined(cachePromise) || params.cache === false) {\n\n                        // always check for requirejs syntax just in case\n                        if ((m = /^(css|less|html|htm|js)?(?=!)/.exec(path)) !== null) {\n                            // Detect file type using preceding type declaration (ala requireJS)\n                            file_type = m[1];\n                            path = path.substr(m[1].length + 1, path.length); // Strip the type from the path\n                        }\n\n                        if (!file_type) {\n                            if ((m = /[.](css|less|html|htm|js)?((\\?|#).*)?$/.exec(path)) !== null) {\n                                // Detect file type via file extension\n                                file_type = m[1];\n                            } else if (!$delegate.jsLoader.hasOwnProperty('ocLazyLoadLoader') && $delegate.jsLoader.hasOwnProperty('load')) {\n                                // requirejs\n                                file_type = 'js';\n                            } else {\n                                $delegate._$log.error('File type could not be determined. ' + path);\n                                return;\n                            }\n                        }\n\n                        if ((file_type === 'css' || file_type === 'less') && cssFiles.indexOf(path) === -1) {\n                            cssFiles.push(path);\n                        } else if ((file_type === 'html' || file_type === 'htm') && templatesFiles.indexOf(path) === -1) {\n                            templatesFiles.push(path);\n                        } else if (file_type === 'js' || jsFiles.indexOf(path) === -1) {\n                            jsFiles.push(path);\n                        } else {\n                            $delegate._$log.error('File type is not valid. ' + path);\n                        }\n                    } else if (cachePromise) {\n                        promises.push(cachePromise);\n                    }\n                };\n\n                if (params.serie) {\n                    pushFile(params.files.shift());\n                } else {\n                    angular.forEach(params.files, function (path) {\n                        pushFile(path);\n                    });\n                }\n\n                if (cssFiles.length > 0) {\n                    var cssDeferred = $q.defer();\n                    $delegate.cssLoader(cssFiles, function (err) {\n                        if (angular.isDefined(err) && $delegate.cssLoader.hasOwnProperty('ocLazyLoadLoader')) {\n                            $delegate._$log.error(err);\n                            cssDeferred.reject(err);\n                        } else {\n                            cssDeferred.resolve();\n                        }\n                    }, params);\n                    promises.push(cssDeferred.promise);\n                }\n\n                if (templatesFiles.length > 0) {\n                    var templatesDeferred = $q.defer();\n                    $delegate.templatesLoader(templatesFiles, function (err) {\n                        if (angular.isDefined(err) && $delegate.templatesLoader.hasOwnProperty('ocLazyLoadLoader')) {\n                            $delegate._$log.error(err);\n                            templatesDeferred.reject(err);\n                        } else {\n                            templatesDeferred.resolve();\n                        }\n                    }, params);\n                    promises.push(templatesDeferred.promise);\n                }\n\n                if (jsFiles.length > 0) {\n                    var jsDeferred = $q.defer();\n                    $delegate.jsLoader(jsFiles, function (err) {\n                        if (angular.isDefined(err) && $delegate.jsLoader.hasOwnProperty('ocLazyLoadLoader')) {\n                            $delegate._$log.error(err);\n                            jsDeferred.reject(err);\n                        } else {\n                            jsDeferred.resolve();\n                        }\n                    }, params);\n                    promises.push(jsDeferred.promise);\n                }\n\n                if (promises.length === 0) {\n                    var deferred = $q.defer(),\n                        err = 'Error: no file to load has been found, if you\\'re trying to load an existing module you should use the \\'inject\\' method instead of \\'load\\'.';\n                    $delegate._$log.error(err);\n                    deferred.reject(err);\n                    return deferred.promise;\n                } else if (params.serie && params.files.length > 0) {\n                    return $q.all(promises).then(function () {\n                        return $delegate.filesLoader(config, params);\n                    });\n                } else {\n                    return $q.all(promises)['finally'](function (res) {\n                        $delegate.toggleWatch(false); // stop watching angular.module calls\n                        return res;\n                    });\n                }\n            };\n\n            /**\n             * Load a module or a list of modules into Angular\n             * @param module Mixed the name of a predefined module config object, or a module config object, or an array of either\n             * @param params Object optional parameters\n             * @returns promise\n             */\n            $delegate.load = function (originalModule) {\n                var originalParams = arguments[1] === undefined ? {} : arguments[1];\n\n                var self = this,\n                    config = null,\n                    deferredList = [],\n                    deferred = $q.defer(),\n                    errText;\n\n                // clean copy\n                var module = angular.copy(originalModule);\n                var params = angular.copy(originalParams);\n\n                // If module is an array, break it down\n                if (angular.isArray(module)) {\n                    // Resubmit each entry as a single module\n                    angular.forEach(module, function (m) {\n                        deferredList.push(self.load(m, params));\n                    });\n\n                    // Resolve the promise once everything has loaded\n                    $q.all(deferredList).then(function (res) {\n                        deferred.resolve(res);\n                    }, function (err) {\n                        deferred.reject(err);\n                    });\n\n                    return deferred.promise;\n                }\n\n                // Get or Set a configuration depending on what was passed in\n                if (angular.isString(module)) {\n                    config = self.getModuleConfig(module);\n                    if (!config) {\n                        config = {\n                            files: [module]\n                        };\n                    }\n                } else if (angular.isObject(module)) {\n                    // case {type: 'js', path: lazyLoadUrl + 'testModule.fakejs'}\n                    if (angular.isDefined(module.path) && angular.isDefined(module.type)) {\n                        config = {\n                            files: [module]\n                        };\n                    } else {\n                        config = self.setModuleConfig(module);\n                    }\n                }\n\n                if (config === null) {\n                    var moduleName = self._getModuleName(module);\n                    errText = 'Module \"' + (moduleName || 'unknown') + '\" is not configured, cannot load.';\n                    $delegate._$log.error(errText);\n                    deferred.reject(new Error(errText));\n                    return deferred.promise;\n                } else {\n                    // deprecated\n                    if (angular.isDefined(config.template)) {\n                        if (angular.isUndefined(config.files)) {\n                            config.files = [];\n                        }\n                        if (angular.isString(config.template)) {\n                            config.files.push(config.template);\n                        } else if (angular.isArray(config.template)) {\n                            config.files.concat(config.template);\n                        }\n                    }\n                }\n\n                var localParams = angular.extend({}, params, config);\n\n                // if someone used an external loader and called the load function with just the module name\n                if (angular.isUndefined(config.files) && angular.isDefined(config.name) && $delegate.moduleExists(config.name)) {\n                    return $delegate.inject(config.name, localParams);\n                }\n\n                $delegate.filesLoader(config, localParams).then(function () {\n                    $delegate.inject(null, localParams).then(function (res) {\n                        deferred.resolve(res);\n                    }, function (err) {\n                        deferred.reject(err);\n                    });\n                }, function (err) {\n                    deferred.reject(err);\n                });\n\n                return deferred.promise;\n            };\n\n            // return the patched service\n            return $delegate;\n        }]);\n    }]);\n})(angular);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').config([\"$provide\", function ($provide) {\n        $provide.decorator('$ocLazyLoad', [\"$delegate\", \"$q\", function ($delegate, $q) {\n            /**\r\n             * cssLoader function\r\n             * @type Function\r\n             * @param paths array list of css files to load\r\n             * @param callback to call when everything is loaded. We use a callback and not a promise\r\n             * @param params object config parameters\r\n             * because the user can overwrite cssLoader and it will probably not use promises :(\r\n             */\n            $delegate.cssLoader = function (paths, callback, params) {\n                var promises = [];\n                angular.forEach(paths, function (path) {\n                    promises.push($delegate.buildElement('css', path, params));\n                });\n                $q.all(promises).then(function () {\n                    callback();\n                }, function (err) {\n                    callback(err);\n                });\n            };\n            $delegate.cssLoader.ocLazyLoadLoader = true;\n\n            return $delegate;\n        }]);\n    }]);\n})(angular);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').config([\"$provide\", function ($provide) {\n        $provide.decorator('$ocLazyLoad', [\"$delegate\", \"$q\", function ($delegate, $q) {\n            /**\r\n             * jsLoader function\r\n             * @type Function\r\n             * @param paths array list of js files to load\r\n             * @param callback to call when everything is loaded. We use a callback and not a promise\r\n             * @param params object config parameters\r\n             * because the user can overwrite jsLoader and it will probably not use promises :(\r\n             */\n            $delegate.jsLoader = function (paths, callback, params) {\n                var promises = [];\n                angular.forEach(paths, function (path) {\n                    promises.push($delegate.buildElement('js', path, params));\n                });\n                $q.all(promises).then(function () {\n                    callback();\n                }, function (err) {\n                    callback(err);\n                });\n            };\n            $delegate.jsLoader.ocLazyLoadLoader = true;\n\n            return $delegate;\n        }]);\n    }]);\n})(angular);\n(function (angular) {\n    'use strict';\n\n    angular.module('oc.lazyLoad').config([\"$provide\", function ($provide) {\n        $provide.decorator('$ocLazyLoad', [\"$delegate\", \"$templateCache\", \"$q\", \"$http\", function ($delegate, $templateCache, $q, $http) {\n            /**\r\n             * templatesLoader function\r\n             * @type Function\r\n             * @param paths array list of css files to load\r\n             * @param callback to call when everything is loaded. We use a callback and not a promise\r\n             * @param params object config parameters for $http\r\n             * because the user can overwrite templatesLoader and it will probably not use promises :(\r\n             */\n            $delegate.templatesLoader = function (paths, callback, params) {\n                var promises = [],\n                    filesCache = $delegate._getFilesCache();\n\n                angular.forEach(paths, function (url) {\n                    var deferred = $q.defer();\n                    promises.push(deferred.promise);\n                    $http.get(url, params).success(function (data) {\n                        if (angular.isString(data) && data.length > 0) {\n                            angular.forEach(angular.element(data), function (node) {\n                                if (node.nodeName === 'SCRIPT' && node.type === 'text/ng-template') {\n                                    $templateCache.put(node.id, node.innerHTML);\n                                }\n                            });\n                        }\n                        if (angular.isUndefined(filesCache.get(url))) {\n                            filesCache.put(url, true);\n                        }\n                        deferred.resolve();\n                    }).error(function (err) {\n                        deferred.reject(new Error('Unable to load template file \"' + url + '\": ' + err));\n                    });\n                });\n                return $q.all(promises).then(function () {\n                    callback();\n                }, function (err) {\n                    callback(err);\n                });\n            };\n            $delegate.templatesLoader.ocLazyLoadLoader = true;\n\n            return $delegate;\n        }]);\n    }]);\n})(angular);\n// Array.indexOf polyfill for IE8\nif (!Array.prototype.indexOf) {\n        Array.prototype.indexOf = function (searchElement, fromIndex) {\n                var k;\n\n                // 1. Let O be the result of calling ToObject passing\n                //    the this value as the argument.\n                if (this == null) {\n                        throw new TypeError('\"this\" is null or not defined');\n                }\n\n                var O = Object(this);\n\n                // 2. Let lenValue be the result of calling the Get\n                //    internal method of O with the argument \"length\".\n                // 3. Let len be ToUint32(lenValue).\n                var len = O.length >>> 0;\n\n                // 4. If len is 0, return -1.\n                if (len === 0) {\n                        return -1;\n                }\n\n                // 5. If argument fromIndex was passed let n be\n                //    ToInteger(fromIndex); else let n be 0.\n                var n = +fromIndex || 0;\n\n                if (Math.abs(n) === Infinity) {\n                        n = 0;\n                }\n\n                // 6. If n >= len, return -1.\n                if (n >= len) {\n                        return -1;\n                }\n\n                // 7. If n >= 0, then Let k be n.\n                // 8. Else, n<0, Let k be len - abs(n).\n                //    If k is less than 0, then let k be 0.\n                k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n                // 9. Repeat, while k < len\n                while (k < len) {\n                        // a. Let Pk be ToString(k).\n                        //   This is implicit for LHS operands of the in operator\n                        // b. Let kPresent be the result of calling the\n                        //    HasProperty internal method of O with argument Pk.\n                        //   This step can be combined with c\n                        // c. If kPresent is true, then\n                        //    i.  Let elementK be the result of calling the Get\n                        //        internal method of O with the argument ToString(k).\n                        //   ii.  Let same be the result of applying the\n                        //        Strict Equality Comparison Algorithm to\n                        //        searchElement and elementK.\n                        //  iii.  If same is true, return k.\n                        if (k in O && O[k] === searchElement) {\n                                return k;\n                        }\n                        k++;\n                }\n                return -1;\n        };\n}\n//# sourceMappingURL=ocLazyLoad.js.map"],"sourceRoot":"/source/"}