} modules A list of module functions or their aliases. See\r\n * {@link angular.module}. The `ng` module must be explicitly added.\r\n * @returns {function()} Injector function. See {@link AUTO.$injector $injector}.\r\n *\r\n * @example\r\n * Typical usage\r\n * \r\n * // create an injector\r\n * var $injector = angular.injector(['ng']);\r\n *\r\n * // use the injector to kick off your application\r\n * // use the type inference to auto inject arguments, or use implicit injection\r\n * $injector.invoke(function($rootScope, $compile, $document){\r\n * $compile($document)($rootScope);\r\n * $rootScope.$digest();\r\n * });\r\n * \r\n */\r\n/**\r\n * @ngdoc overview\r\n * @name AUTO\r\n * @description\r\n *\r\n * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.\r\n */\r\nvar ARROW_ARG = /^([^(]+?)=>/;\r\nvar FN_ARGS = /^[^(]*\\(\\s*([^)]*)\\)/m;\r\nvar FN_ARG_SPLIT = /,/;\r\nvar FN_ARG = /^\\s*(_?)(\\S+?)\\1\\s*$/;\r\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/mg;\r\nvar $injectorMinErr = lib_minErr('$injector');\r\nfunction stringifyFn(fn) {\r\n return Function.prototype.toString.call(fn);\r\n}\r\nfunction extractArgs(fn) {\r\n var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ''), args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);\r\n return args;\r\n}\r\nfunction anonFn(fn) {\r\n // For anonymous functions, showing at the very least the function signature can help in\r\n // debugging.\r\n var args = extractArgs(fn);\r\n if (args) {\r\n return 'function(' + (args[1] || '').replace(/[\\s\\r\\n]+/, ' ') + ')';\r\n }\r\n return 'fn';\r\n}\r\nfunction annotate(fn, strictDi, name) {\r\n var $inject, argDecl, last;\r\n if (typeof fn === 'function') {\r\n if (!($inject = fn.$inject)) {\r\n $inject = [];\r\n if (fn.length) {\r\n if (strictDi) {\r\n if (!isString(name) || !name) {\r\n name = fn.name || anonFn(fn);\r\n }\r\n throw $injectorMinErr('strictdi', '{0} is not using explicit annotation and cannot be invoked in strict mode', name);\r\n }\r\n argDecl = extractArgs(fn);\r\n forEach(argDecl[1].split(FN_ARG_SPLIT), function (arg) {\r\n arg.replace(FN_ARG, function (all, underscore, name) {\r\n $inject.push(name);\r\n });\r\n });\r\n }\r\n fn.$inject = $inject;\r\n }\r\n }\r\n else if (Array.isArray(fn)) {\r\n last = fn.length - 1;\r\n assertArgFn(fn[last], 'fn');\r\n $inject = fn.slice(0, last);\r\n }\r\n else {\r\n assertArgFn(fn, 'fn', true);\r\n }\r\n return $inject;\r\n}\r\n///////////////////////////////////////\r\n/**\r\n * @ngdoc object\r\n * @name AUTO.$injector\r\n * @function\r\n *\r\n * @description\r\n *\r\n * `$injector` is used to retrieve object instances as defined by\r\n * {@link AUTO.$provide provider}, instantiate types, invoke methods,\r\n * and load modules.\r\n *\r\n * The following always holds true:\r\n *\r\n * \r\n * var $injector = angular.injector();\r\n * expect($injector.get('$injector')).toBe($injector);\r\n * expect($injector.invoke(function($injector){\r\n * return $injector;\r\n * }).toBe($injector);\r\n * \r\n *\r\n * # Injection Function Annotation\r\n *\r\n * JavaScript does not have annotations, and annotations are needed for dependency injection. The\r\n * following ways are all valid way of annotating function with injection arguments and are equivalent.\r\n *\r\n * \r\n * // inferred (only works if code not minified/obfuscated)\r\n * $injector.invoke(function(serviceA){});\r\n *\r\n * // annotated\r\n * function explicit(serviceA) {};\r\n * explicit.$inject = ['serviceA'];\r\n * $injector.invoke(explicit);\r\n *\r\n * // inline\r\n * $injector.invoke(['serviceA', function(serviceA){}]);\r\n * \r\n *\r\n * ## Inference\r\n *\r\n * In JavaScript calling `toString()` on a function returns the function definition. The definition can then be\r\n * parsed and the function arguments can be extracted. *NOTE:* This does not work with minification, and obfuscation\r\n * tools since these tools change the argument names.\r\n *\r\n * ## `$inject` Annotation\r\n * By adding a `$inject` property onto a function the injection parameters can be specified.\r\n *\r\n * ## Inline\r\n * As an array of injection names, where the last item in the array is the function to call.\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$injector#get\r\n * @methodOf AUTO.$injector\r\n *\r\n * @description\r\n * Return an instance of the service.\r\n *\r\n * @param {string} name The name of the instance to retrieve.\r\n * @return {*} The instance.\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$injector#invoke\r\n * @methodOf AUTO.$injector\r\n *\r\n * @description\r\n * Invoke the method and supply the method arguments from the `$injector`.\r\n *\r\n * @param {!function} fn The function to invoke. The function arguments come form the function annotation.\r\n * @param {Object=} self The `this` for the invoked method.\r\n * @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before\r\n * the `$injector` is consulted.\r\n * @returns {*} the value returned by the invoked `fn` function.\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$injector#instantiate\r\n * @methodOf AUTO.$injector\r\n * @description\r\n * Create a new instance of JS type. The method takes a constructor function invokes the new operator and supplies\r\n * all of the arguments to the constructor function as specified by the constructor annotation.\r\n *\r\n * @param {function} Type Annotated constructor function.\r\n * @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before\r\n * the `$injector` is consulted.\r\n * @returns {Object} new instance of `Type`.\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$injector#annotate\r\n * @methodOf AUTO.$injector\r\n *\r\n * @description\r\n * Returns an array of service names which the function is requesting for injection. This API is used by the injector\r\n * to determine which services need to be injected into the function when the function is invoked. There are three\r\n * ways in which the function can be annotated with the needed dependencies.\r\n *\r\n * # Argument names\r\n *\r\n * The simplest form is to extract the dependencies from the arguments of the function. This is done by converting\r\n * the function into a string using `toString()` method and extracting the argument names.\r\n * \r\n * // Given\r\n * function MyController($scope, $route) {\r\n * // ...\r\n * }\r\n *\r\n * // Then\r\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\r\n * \r\n *\r\n * This method does not work with code minfication / obfuscation. For this reason the following annotation strategies\r\n * are supported.\r\n *\r\n * # The `$inject` property\r\n *\r\n * If a function has an `$inject` property and its value is an array of strings, then the strings represent names of\r\n * services to be injected into the function.\r\n * \r\n * // Given\r\n * var MyController = function(obfuscatedScope, obfuscatedRoute) {\r\n * // ...\r\n * }\r\n * // Define function dependencies\r\n * MyController.$inject = ['$scope', '$route'];\r\n *\r\n * // Then\r\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\r\n * \r\n *\r\n * # The array notation\r\n *\r\n * It is often desirable to inline Injected functions and that's when setting the `$inject` property is very\r\n * inconvenient. In these situations using the array notation to specify the dependencies in a way that survives\r\n * minification is a better choice:\r\n *\r\n * \r\n * // We wish to write this (not minification / obfuscation safe)\r\n * injector.invoke(function($compile, $rootScope) {\r\n * // ...\r\n * });\r\n *\r\n * // We are forced to write break inlining\r\n * var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {\r\n * // ...\r\n * };\r\n * tmpFn.$inject = ['$compile', '$rootScope'];\r\n * injector.invoke(tempFn);\r\n *\r\n * // To better support inline function the inline annotation is supported\r\n * injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {\r\n * // ...\r\n * }]);\r\n *\r\n * // Therefore\r\n * expect(injector.annotate(\r\n * ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])\r\n * ).toEqual(['$compile', '$rootScope']);\r\n * \r\n *\r\n * @param {function|Array.} fn Function for which dependent service names need to be retrieved as described\r\n * above.\r\n *\r\n * @returns {Array.} The names of the services which the function requires.\r\n */\r\n/**\r\n * @ngdoc object\r\n * @name AUTO.$provide\r\n *\r\n * @description\r\n *\r\n * Use `$provide` to register new providers with the `$injector`. The providers are the factories for the instance.\r\n * The providers share the same name as the instance they create with `Provider` suffixed to them.\r\n *\r\n * A provider is an object with a `$get()` method. The injector calls the `$get` method to create a new instance of\r\n * a service. The Provider can have additional methods which would allow for configuration of the provider.\r\n *\r\n * \r\n * function GreetProvider() {\r\n * var salutation = 'Hello';\r\n *\r\n * this.salutation = function(text) {\r\n * salutation = text;\r\n * };\r\n *\r\n * this.$get = function() {\r\n * return function (name) {\r\n * return salutation + ' ' + name + '!';\r\n * };\r\n * };\r\n * }\r\n *\r\n * describe('Greeter', function(){\r\n *\r\n * beforeEach(module(function($provide) {\r\n * $provide.provider('greet', GreetProvider);\r\n * });\r\n *\r\n * it('should greet', inject(function(greet) {\r\n * expect(greet('angular')).toEqual('Hello angular!');\r\n * }));\r\n *\r\n * it('should allow configuration of salutation', function() {\r\n * module(function(greetProvider) {\r\n * greetProvider.salutation('Ahoj');\r\n * });\r\n * inject(function(greet) {\r\n * expect(greet('angular')).toEqual('Ahoj angular!');\r\n * });\r\n * )};\r\n *\r\n * });\r\n * \r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#provider\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * Register a provider for a service. The providers can be retrieved and can have additional configuration methods.\r\n *\r\n * @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provider'` key.\r\n * @param {(Object|function())} provider If the provider is:\r\n *\r\n * - `Object`: then it should have a `$get` method. The `$get` method will be invoked using\r\n * {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.\r\n * - `Constructor`: a new instance of the provider will be created using\r\n * {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.\r\n *\r\n * @returns {Object} registered provider instance\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#factory\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * A short hand for configuring services if only `$get` method is required.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand for\r\n * `$provide.provider(name, {$get: $getFn})`.\r\n * @returns {Object} registered provider instance\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#service\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * A short hand for registering service of given class.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {Function} constructor A class (constructor function) that will be instantiated.\r\n * @returns {Object} registered provider instance\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#value\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * A short hand for configuring services if the `$get` method is a constant.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {*} value The value.\r\n * @returns {Object} registered provider instance\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#constant\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * A constant value, but unlike {@link AUTO.$provide#value value} it can be injected\r\n * into configuration function (other modules) and it is not interceptable by\r\n * {@link AUTO.$provide#decorator decorator}.\r\n *\r\n * @param {string} name The name of the constant.\r\n * @param {*} value The constant value.\r\n * @returns {Object} registered instance\r\n */\r\n/**\r\n * @ngdoc method\r\n * @name AUTO.$provide#decorator\r\n * @methodOf AUTO.$provide\r\n * @description\r\n *\r\n * Decoration of service, allows the decorator to intercept the service instance creation. The\r\n * returned instance may be the original instance, or a new instance which delegates to the\r\n * original instance.\r\n *\r\n * @param {string} name The name of the service to decorate.\r\n * @param {function()} decorator This function will be invoked when the service needs to be\r\n * instanciated. The function is called using the {@link AUTO.$injector#invoke\r\n * injector.invoke} method and is therefore fully injectable. Local injection arguments:\r\n *\r\n * * `$delegate` - The original service instance, which can be monkey patched, configured,\r\n * decorated or delegated to.\r\n */\r\n/**\r\n * Create an injector, loading the given modules.\r\n *\r\n * The modules can be a list of ids, config functions, or injectable config functions (array annotations).\r\n * `strictDi` defaults to true; meaning that all injectable functions must be wrapped in an annotation array.\r\n */\r\nfunction createInjectorStrict(modulesToLoad, strictDi) {\r\n if (strictDi === void 0) { strictDi = true; }\r\n strictDi = (strictDi !== false);\r\n return createInjector(modulesToLoad, strictDi);\r\n}\r\nfunction createInjector(modulesToLoad, strictDi) {\r\n // // @wiwo default strictDi to true\r\n // strictDi = (strictDi !== false);\r\n strictDi = (strictDi === true);\r\n var INSTANTIATING = {}, providerSuffix = 'Provider', path = [], loadedModules = new hashmap(), providerCache = {\r\n $provide: {\r\n provider: supportObject(provider),\r\n factory: supportObject(factory),\r\n service: supportObject(service),\r\n value: supportObject(value),\r\n constant: supportObject(constant),\r\n decorator: decorator\r\n },\r\n $injector: null,\r\n }, providerInjector = (providerCache.$injector =\r\n createInternalInjector(providerCache, function (serviceName, caller) {\r\n if (isString(caller)) {\r\n path.push(caller);\r\n }\r\n throw $injectorMinErr('unpr', 'Unknown provider: {0}', path.join(' <- '));\r\n })), instanceCache = {}, protoInstanceInjector = createInternalInjector(instanceCache, function (serviceName, caller) {\r\n var provider = providerInjector.get(serviceName + providerSuffix, caller);\r\n return instanceInjector.invoke(provider.$get, provider, undefined, serviceName);\r\n }), instanceInjector = protoInstanceInjector;\r\n providerCache['$injector' + providerSuffix] = { $get: valueFn(protoInstanceInjector) };\r\n instanceInjector.modules = providerInjector.modules = createMap();\r\n var runBlocks = loadModules(modulesToLoad);\r\n instanceInjector = protoInstanceInjector.get('$injector');\r\n instanceInjector.strictDi = strictDi;\r\n forEach(runBlocks, function (fn) { if (fn)\r\n instanceInjector.invoke(fn); });\r\n instanceInjector.loadNewModules = function (mods) {\r\n forEach(loadModules(mods), function (fn) { if (fn)\r\n instanceInjector.invoke(fn); });\r\n };\r\n return instanceInjector;\r\n ////////////////////////////////////\r\n // $provider\r\n ////////////////////////////////////\r\n function supportObject(delegate) {\r\n return function supportObjectInternal(key, value) {\r\n if (utils_isObject(key)) {\r\n forEach(key, reverseParams(delegate));\r\n }\r\n else {\r\n return delegate(key, value);\r\n }\r\n };\r\n }\r\n function provider(name, provider_) {\r\n assertNotHasOwnProperty(name, 'service');\r\n if (isFunction(provider_) || Array.isArray(provider_)) {\r\n provider_ = providerInjector.instantiate(provider_);\r\n }\r\n if (!provider_.$get) {\r\n throw $injectorMinErr('pget', 'Provider \\'{0}\\' must define $get factory method.', name);\r\n }\r\n return (providerCache[name + providerSuffix] = provider_);\r\n }\r\n function enforceReturnValue(name, factory) {\r\n return /** @this */ function enforcedReturnValue() {\r\n var result = instanceInjector.invoke(factory, this);\r\n if (isUndefined(result)) {\r\n throw $injectorMinErr('undef', 'Provider \\'{0}\\' must return a value from $get factory method.', name);\r\n }\r\n return result;\r\n };\r\n }\r\n function factory(name, factoryFn, enforce) {\r\n return provider(name, {\r\n $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn\r\n });\r\n }\r\n function service(name, constructor) {\r\n return factory(name, ['$injector', function ($injector) {\r\n return $injector.instantiate(constructor);\r\n }]);\r\n }\r\n function value(name, val) { return factory(name, valueFn(val), false); }\r\n function constant(name, value) {\r\n assertNotHasOwnProperty(name, 'constant');\r\n providerCache[name] = value;\r\n instanceCache[name] = value;\r\n }\r\n function decorator(serviceName, decorFn) {\r\n var origProvider = providerInjector.get(serviceName + providerSuffix), orig$get = origProvider.$get;\r\n origProvider.$get = function () {\r\n var origInstance = instanceInjector.invoke(orig$get, origProvider);\r\n return instanceInjector.invoke(decorFn, null, { $delegate: origInstance });\r\n };\r\n }\r\n ////////////////////////////////////\r\n // Module Loading\r\n ////////////////////////////////////\r\n function loadModules(modulesToLoad) {\r\n assertArg(isUndefined(modulesToLoad) || Array.isArray(modulesToLoad), 'modulesToLoad', 'not an array');\r\n var runBlocks = [], moduleFn;\r\n modulesToLoad && modulesToLoad.forEach(function (module) {\r\n if (loadedModules.get(module))\r\n return;\r\n loadedModules.set(module, true);\r\n function runInvokeQueue(queue) {\r\n var i, ii;\r\n for (i = 0, ii = queue.length; i < ii; i++) {\r\n var invokeArgs = queue[i], provider = providerInjector.get(invokeArgs[0]);\r\n provider[invokeArgs[1]].apply(provider, invokeArgs[2]);\r\n }\r\n }\r\n try {\r\n if (isString(module)) {\r\n moduleFn = lib_defaultModuleLoader(module);\r\n instanceInjector.modules[module] = moduleFn;\r\n runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);\r\n runInvokeQueue(moduleFn._invokeQueue);\r\n runInvokeQueue(moduleFn._configBlocks);\r\n }\r\n else if (isFunction(module)) {\r\n runBlocks.push(providerInjector.invoke(module));\r\n }\r\n else if (Array.isArray(module)) {\r\n runBlocks.push(providerInjector.invoke(module));\r\n }\r\n else {\r\n assertArgFn(module, 'module');\r\n }\r\n }\r\n catch (e) {\r\n if (Array.isArray(module)) {\r\n module = module[module.length - 1];\r\n }\r\n if (e.message && e.stack && e.stack.indexOf(e.message) === -1) {\r\n // Safari & FF's stack traces don't contain error.message content\r\n // unlike those of Chrome and IE\r\n // So if stack doesn't contain message, we create a new string that contains both.\r\n // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.\r\n // eslint-disable-next-line no-ex-assign\r\n e = e.message + '\\n' + e.stack;\r\n }\r\n throw $injectorMinErr('modulerr', 'Failed to instantiate module {0} due to:\\n{1}', module, e.stack || e.message || e);\r\n }\r\n });\r\n return runBlocks;\r\n }\r\n ////////////////////////////////////\r\n // internal Injector\r\n ////////////////////////////////////\r\n function createInternalInjector(cache, factory) {\r\n function getService(serviceName, caller) {\r\n if (cache.hasOwnProperty(serviceName)) {\r\n if (cache[serviceName] === INSTANTIATING) {\r\n throw $injectorMinErr('cdep', 'Circular dependency found: {0}', serviceName + ' <- ' + path.join(' <- '));\r\n }\r\n return cache[serviceName];\r\n }\r\n else {\r\n try {\r\n path.unshift(serviceName);\r\n cache[serviceName] = INSTANTIATING;\r\n cache[serviceName] = factory(serviceName, caller);\r\n return cache[serviceName];\r\n }\r\n catch (err) {\r\n if (cache[serviceName] === INSTANTIATING) {\r\n delete cache[serviceName];\r\n }\r\n throw err;\r\n }\r\n finally {\r\n path.shift();\r\n }\r\n }\r\n }\r\n function injectionArgs(fn, locals, serviceName) {\r\n var args = [], \r\n // $inject = createInjector.$$annotate(fn, strictDi, serviceName);\r\n $inject = createInjectorStrict.$$annotate(fn, strictDi, serviceName);\r\n for (var i = 0, length = $inject.length; i < length; i++) {\r\n var key = $inject[i];\r\n if (typeof key !== 'string') {\r\n throw $injectorMinErr('itkn', 'Incorrect injection token! Expected service name as string, got {0}', key);\r\n }\r\n args.push(locals && locals.hasOwnProperty(key) ? locals[key] :\r\n getService(key, serviceName));\r\n }\r\n return args;\r\n }\r\n /**\r\n * 2022-01-14\r\n * CFH - possible alternative for determining function vs class\r\n */\r\n function isClass(func) {\r\n // Support: IE 9-11 only\r\n // IE 9-11 do not support classes and IE9 leaks with the code below.\r\n if (msie || typeof func !== 'function') {\r\n return false;\r\n }\r\n var result = func.$$ngIsClass;\r\n if (!utils_isBoolean(result)) {\r\n // Support: Edge 12-13 only\r\n // See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6156135/\r\n result = func.$$ngIsClass = /^(?:class\\b|constructor\\()/.test(stringifyFn(func));\r\n }\r\n return result;\r\n }\r\n function invoke(fn, self, locals, serviceName) {\r\n if (typeof locals === 'string') {\r\n serviceName = locals;\r\n locals = null;\r\n }\r\n var args = injectionArgs(fn, locals, serviceName);\r\n if (Array.isArray(fn)) {\r\n fn = fn[fn.length - 1];\r\n }\r\n if (!isClass(fn)) {\r\n // http://jsperf.com/angularjs-invoke-apply-vs-switch\r\n // #5388\r\n return fn.apply(self, args);\r\n }\r\n else {\r\n args.unshift(null);\r\n return new (Function.prototype.bind.apply(fn, args))();\r\n }\r\n }\r\n function instantiate(Type, locals, serviceName) {\r\n // Check if Type is annotated and use just the given function at n-1 as parameter\r\n // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);\r\n var ctor = (Array.isArray(Type) ? Type[Type.length - 1] : Type);\r\n var args = injectionArgs(Type, locals, serviceName);\r\n // Empty object at position 0 is ignored for invocation with `new`, but required.\r\n args.unshift(null);\r\n return new (Function.prototype.bind.apply(ctor, args))();\r\n }\r\n return {\r\n invoke: invoke,\r\n instantiate: instantiate,\r\n get: getService,\r\n // annotate: createInjector.$$annotate,\r\n annotate: createInjectorStrict.$$annotate,\r\n has: function (name) {\r\n return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);\r\n },\r\n modules: null,\r\n //loadNewModules\r\n // @wiwo extension:\r\n keys: function () { return Object.keys(providerCache); }\r\n };\r\n }\r\n}\r\n;\r\ncreateInjectorStrict.$$annotate = annotate;\r\ncreateInjector.$$annotate = annotate;\r\nvar injectorMod = {\r\n createInjectorStrict: createInjectorStrict,\r\n createInjector: createInjector,\r\n annotate: annotate,\r\n};\r\n/* harmony default export */ const injector = ((/* unused pure expression or super */ null && (injectorMod)));\r\n\r\n\n;// CONCATENATED MODULE: ./node_modules/@wiwo/ngdi/dist/ngdi.js\n/*\r\n * @wiwo/ngdi\r\n *\r\n * Copyright (c) 2013 Javier Mendiara Cañardo\r\n * Licensed under the MIT license.\r\n */\r\n\r\n\r\n\r\nvar ngdi_module = lib_defaultModuleLoader;\r\nvar ngdi_injector = createInjectorStrict;\r\nvar ngdi_annotate = annotate;\r\nvar utils = utils_namespaceObject;\r\n/**\r\n * Usage:\r\n *\r\n * import di from '@wiwo/ngdi';\r\n *\r\n * // See: https://docs.angularjs.org/api/ng/function/angular.module\r\n * di.module('', []);\r\n *\r\n * // See: https://docs.angularjs.org/api/ng/function/angular.injector\r\n * const $injector = di.injector(['modules']);\r\n *\r\n * $injector.get('name');\r\n *\r\n * $injector.invoke(['serviceName', function(serviceName){\r\n *\r\n * }]);\r\n */\r\nvar di = {\r\n module: ngdi_module,\r\n injector: ngdi_injector,\r\n annotate: ngdi_annotate,\r\n utils: utils,\r\n toJson: utils.toJson,\r\n};\r\n/* harmony default export */ const ngdi = (di);\r\n\n;// CONCATENATED MODULE: ./node_modules/@wiwo/ngdi/dist/legacy/legacy.js\nvar legacyRegistrations = {};\r\n/**\r\n * TODO: CFH work out if we need to implement proper legacy filter support\r\n *\r\n * Pass the `module` loader function (i.e. the function that gets/creates modules) (i.e. `angular.module` or `di.module`)\r\n *\r\n * Returns a new function that registers/retrieves the module\r\n *\r\n * moduleLoader:\r\n * di('moduleName', ['dependencyList'])\r\n * di('moduleName')\r\n */\r\nfunction legacy(moduleLoader, options) {\r\n options = options || {};\r\n var _options = {\r\n log: true,\r\n };\r\n for (var i in _options) {\r\n // only copy known properties\r\n if (options.hasOwnProperty(i)) {\r\n _options[i] = options[i];\r\n }\r\n }\r\n var logMap = {};\r\n /**\r\n * @param {string} name\r\n * @param {string[]} requires (optional)\r\n * @param {Function} configFn (optional)\r\n */\r\n function wrappedModuleLoader(name, requires, configFn) {\r\n var module = moduleLoader(name, requires, configFn);\r\n // If we're defining a new module\r\n if (Array.isArray(requires)) {\r\n [\r\n 'filter',\r\n 'controller',\r\n 'directive',\r\n 'component',\r\n ].forEach(function (type) {\r\n // Don't override existing functions (e.g. if `angular` is passed in)\r\n if (module[type]) {\r\n return;\r\n }\r\n // Augment the returned module with additional function types\r\n module[type] = function (name) {\r\n /*\r\n Warn the first time an unsupported type is registered so we can track it down.\r\n */\r\n if (_options.log && !logMap[type]) {\r\n logMap[type] = true;\r\n console.warn(\"(@wiwo/ngdi) unsupported legacy registration: type=\\\"\".concat(type, \"\\\", name=\\\"\").concat(name, \"\\\". See 'module.$legacyRegistrations' for all unsupported registrations\"));\r\n }\r\n var list = legacyRegistrations[type] || (legacyRegistrations[type] = []);\r\n list.push(name);\r\n };\r\n });\r\n }\r\n return module;\r\n }\r\n /**\r\n * Make the legacy registrations available externally\r\n *\r\n * `ngdi.module.$legacyRegistrations`\r\n */\r\n wrappedModuleLoader.$legacyRegistrations = legacyRegistrations;\r\n wrappedModuleLoader.$originalLoader = moduleLoader;\r\n return wrappedModuleLoader;\r\n}\r\n\n;// CONCATENATED MODULE: ./node_modules/@wiwo/ngdi/dist/legacy.js\n\r\n\r\n/**\r\n * Add dummy functions for these angular module methods:\r\n *\r\n * - filter\r\n * - controller\r\n * - directive\r\n * - component\r\n *\r\n * `$legacyRegistraions` is a map that holds any of these legacy registraions\r\n * that have been ignored.\r\n */\r\nfunction wrapLegacy(di, options) {\r\n di.module = legacy(di.module, options);\r\n return di;\r\n}\r\n// restore the original module loader instance\r\nfunction unwrapLegacy(di) {\r\n if (di.module.$originalLoader) {\r\n di.module = di.module.$originalLoader;\r\n }\r\n return di;\r\n}\r\n\n;// CONCATENATED MODULE: ./src/cba-card-selector/javascripts/_di.ts\n\n\nwrapLegacy(ngdi, {\n log: false\n});\n// wrapLegacy(ngdi, {log: true});\nvar DI_CONTAINER = ngdi;\n// export const DI_CONTAINER = angular;\n\n/***/ }),\n\n/***/ 5109:\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */ I: () => (/* binding */ FinderDebugProvider),\n/* harmony export */ m: () => (/* binding */ FinderDebugContext)\n/* harmony export */ });\n/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7294);\n\nvar FinderDebugContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(null);\nvar FinderDebugProvider = FinderDebugContext.Provider;\n\n/***/ }),\n\n/***/ 2109:\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */ P: () => (/* binding */ FinderFooterDebug)\n/* harmony export */ });\n/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7294);\n\nvar FinderFooterDebug = {\n render: function FinderFooterDebug(props) {\n return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react__WEBPACK_IMPORTED_MODULE_0__.Fragment, null);\n }\n};\n\n/***/ }),\n\n/***/ 8289:\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n//! © 2015 Nathan Rugg | MIT\n/// See LICENSE for more details.\n\n/// Let's use Web Workers.\n///NOTE: The \"this\" keyword is the global context (\"window\" variable) if loaded via a