PageSourceSearch

https://smartrack.live/lib/angular-translate/angular-translate.min.js

js smartrack.live collected 2026-10-02 01:05:16 UTC 59,629 bytes, 1,065 lines download raw bytes

vendor: 17,153 bytes, lines 1-305
1/*!
2 * angular-translate - v2.11.0 - 2016-03-20
3 * 
4 * Copyright (c) 2016 The angular-translate team, Pascal Precht; Licensed MIT
5 */
6!function(a,b){"function"==typeof define&&define.amd?
7// AMD. Register as an anonymous module unless amdModuleId is set
8define([],function(){return b()}):"object"==typeof exports?
9// Node. Does not work with strict CommonJS, but
10// only CommonJS-like environments that support module.exports,
11// like Node.
12module.exports=b():b()}(this,function(){function a(a){"use strict";var b=a.storageKey(),c=a.storage(),d=function(){var d=a.preferredLanguage();angular.isString(d)?a.use(d):c.put(b,a.use())};d.displayName="fallbackFromIncorrectStorageValue",c?c.get(b)?a.use(c.get(b))["catch"](d):d():angular.isString(a.preferredLanguage())&&a.use(a.preferredLanguage())}function b(){"use strict";var a,b,c=null,// TODO change to either 'sanitize', 'escape' or ['sanitize', 'escapeParameters'] in 3.0.
13d=!1,e=!1;b={sanitize:function(a,b){return"text"===b&&(a=g(a)),a},escape:function(a,b){return"text"===b&&(a=f(a)),a},sanitizeParameters:function(a,b){return"params"===b&&(a=h(a,g)),a},escapeParameters:function(a,b){return"params"===b&&(a=h(a,f)),a}},b.escaped=b.escapeParameters,this.addStrategy=function(a,c){return b[a]=c,this},this.removeStrategy=function(a){return delete b[a],this},this.useStrategy=function(a){return d=!0,c=a,this},this.$get=["$injector","$log",function(f,g){var h={},i=function(a,c,d){return angular.forEach(d,function(d){if(angular.isFunction(d))a=d(a,c);else if(angular.isFunction(b[d]))a=b[d](a,c);else{if(!angular.isString(b[d]))throw new Error("pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: '"+d+"'");if(!h[b[d]])try{h[b[d]]=f.get(b[d])}catch(e){throw h[b[d]]=function(){},new Error("pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: '"+d+"'")}a=h[b[d]](a,c)}}),a},j=function(){d||e||(g.warn("pascalprecht.translate.$translateSanitization: No sanitization strategy has been configured. This can have serious security implications. See http://angular-translate.github.io/docs/#/guide/19_security for details."),e=!0)};return f.has("$sanitize")&&(a=f.get("$sanitize")),{useStrategy:function(a){return function(b){a.useStrategy(b)}}(this),sanitize:function(a,b,d){if(c||j(),arguments.length<3&&(d=c),!d)return a;var e=angular.isArray(d)?d:[d];return i(a,b,e)}}}];var f=function(a){var b=angular.element("<div></div>");// not chainable, see #1044
14return b.text(a),b.html()},g=function(b){if(!a)throw new Error("pascalprecht.translate.$translateSanitization: Error cannot find $sanitize service. Either include the ngSanitize module (https://docs.angularjs.org/api/ngSanitize) or use a sanitization strategy which does not depend on $sanitize, such as 'escape'.");return a(b)},h=function(a,b,c){if(angular.isObject(a)){var d=angular.isArray(a)?[]:{};if(c){if(c.indexOf(a)>-1)throw new Error("pascalprecht.translate.$translateSanitization: Error cannot interpolate parameter due recursive object")}else c=[];// remove last
15return c.push(a),angular.forEach(a,function(a,e){d[e]=h(a,b,c)}),c.splice(-1,1),d}return angular.isNumber(a)?a:b(a)}}function c(a,b,c,d){"use strict";var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u={},v=[],w=a,x=[],y="translate-cloak",z=!1,A=!1,B=".",C=!1,D=0,E=!0,F="default",G={"default":function(a){return(a||"").split("-").join("_")},java:function(a){var b=(a||"").split("-").join("_"),c=b.split("_");return c.length>1?c[0].toLowerCase()+"_"+c[1].toUpperCase():b},bcp47:function(a){var b=(a||"").split("_").join("-"),c=b.split("-");return c.length>1?c[0].toLowerCase()+"-"+c[1].toUpperCase():b},"iso639-1":function(a){var b=(a||"").split("_").join("-"),c=b.split("-");return c[0].toLowerCase()}},H="2.11.0",I=function(){
16// internal purpose only
17if(angular.isFunction(d.getLocale))return d.getLocale();var a,c,e=b.$get().navigator,f=["language","browserLanguage","systemLanguage","userLanguage"];
18// support for HTML 5.1 "navigator.languages"
19if(angular.isArray(e.languages))for(a=0;a<e.languages.length;a++)if(c=e.languages[a],c&&c.length)return c;
20// support for other well known properties in browsers
21for(a=0;a<f.length;a++)if(c=e[f[a]],c&&c.length)return c;return null};I.displayName="angular-translate/service: getFirstBrowserLanguage";
22// tries to determine the browsers locale
23var J=function(){var a=I()||"";return G[F]&&(a=G[F](a)),a};J.displayName="angular-translate/service: getLocale";/**
24   * @name indexOf
25   * @private
26   *
27   * @description
28   * indexOf polyfill. Kinda sorta.
29   *
30   * @param {array} array Array to search in.
31   * @param {string} searchElement Element to search for.
32   *
33   * @returns {int} Index of search element.
34   */
35var K=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},L=function(){return this.toString().replace(/^\s+|\s+$/g,"")},M=function(a){if(a){for(var b=[],c=angular.lowercase(a),d=0,e=v.length;e>d;d++)b.push(angular.lowercase(v[d]));
36// Check for an exact match in our list of available keys
37if(K(b,c)>-1)return a;if(f){var g;for(var h in f)if(f.hasOwnProperty(h)){var i=!1,j=Object.prototype.hasOwnProperty.call(f,h)&&angular.lowercase(h)===angular.lowercase(a);if("*"===h.slice(-1)&&(i=h.slice(0,-1)===a.slice(0,h.length-1)),(j||i)&&(g=f[h],K(b,angular.lowercase(g))>-1))return g}}
38// Check for a language code without region
39var k=a.split("_");return k.length>1&&K(b,angular.lowercase(k[0]))>-1?k[0]:void 0}},N=function(a,b){if(!a&&!b)return u;if(a&&!b){if(angular.isString(a))return u[a]}else angular.isObject(u[a])||(u[a]={}),angular.extend(u[a],O(b));return this};this.translations=N,/**
40   * @ngdoc function
41   * @name pascalprecht.translate.$translateProvider#cloakClassName
42   * @methodOf pascalprecht.translate.$translateProvider
43   *
44   * @description
45   *
46   * Let's you change the class name for `translate-cloak` directive.
47   * Default class name is `translate-cloak`.
48   *
49   * @param {string} name translate-cloak class name
50   */
51this.cloakClassName=function(a){return a?(y=a,this):y},/**
52   * @ngdoc function
53   * @name pascalprecht.translate.$translateProvider#nestedObjectDelimeter
54   * @methodOf pascalprecht.translate.$translateProvider
55   *
56   * @description
57   *
58   * Let's you change the delimiter for namespaced translations.
59   * Default delimiter is `.`.
60   *
61   * @param {string} delimiter namespace separator
62   */
63this.nestedObjectDelimeter=function(a){return a?(B=a,this):B};/**
64   * @name flatObject
65   * @private
66   *
67   * @description
68   * Flats an object. This function is used to flatten given translation data with
69   * namespaces, so they are later accessible via dot notation.
70   */
71var O=function(a,b,c,d){var e,f,g,h;b||(b=[]),c||(c={});for(e in a)Object.prototype.hasOwnProperty.call(a,e)&&(h=a[e],angular.isObject(h)?O(h,b.concat(e),c,e):(f=b.length?""+b.join(B)+B+e:e,b.length&&e===d&&(g=""+b.join(B),c[g]="@:"+f),c[f]=h));return c};O.displayName="flatObject",/**
72   * @ngdoc function
73   * @name pascalprecht.translate.$translateProvider#addInterpolation
74   * @methodOf pascalprecht.translate.$translateProvider
75   *
76   * @description
77   * Adds interpolation services to angular-translate, so it can manage them.
78   *
79   * @param {object} factory Interpolation service factory
80   */
81this.addInterpolation=function(a){return x.push(a),this},/**
82   * @ngdoc function
83   * @name pascalprecht.translate.$translateProvider#useMessageFormatInterpolation
84   * @methodOf pascalprecht.translate.$translateProvider
85   *
86   * @description
87   * Tells angular-translate to use interpolation functionality of messageformat.js.
88   * This is useful when having high level pluralization and gender selection.
89   */
90this.useMessageFormatInterpolation=function(){return this.useInterpolation("$translateMessageFormatInterpolation")},/**
91   * @ngdoc function
92   * @name pascalprecht.translate.$translateProvider#useInterpolation
93   * @methodOf pascalprecht.translate.$translateProvider
94   *
95   * @description
96   * Tells angular-translate which interpolation style to use as default, application-wide.
97   * Simply pass a factory/service name. The interpolation service has to implement
98   * the correct interface.
99   *
100   * @param {string} factory Interpolation service name.
101   */
102this.useInterpolation=function(a){return n=a,this},/**
103   * @ngdoc function
104   * @name pascalprecht.translate.$translateProvider#useSanitizeStrategy
105   * @methodOf pascalprecht.translate.$translateProvider
106   *
107   * @description
108   * Simply sets a sanitation strategy type.
109   *
110   * @param {string} value Strategy type.
111   */
112this.useSanitizeValueStrategy=function(a){return c.useStrategy(a),this},/**
113   * @ngdoc function
114   * @name pascalprecht.translate.$translateProvider#preferredLanguage
115   * @methodOf pascalprecht.translate.$translateProvider
116   *
117   * @description
118   * Tells the module which of the registered translation tables to use for translation
119   * at initial startup by passing a language key. Similar to `$translateProvider#use`
120   * only that it says which language to **prefer**.
121   *
122   * @param {string} langKey A language key.
123   */
124this.preferredLanguage=function(a){return a?(P(a),this):e};var P=function(a){return a&&(e=a),e};/**
125   * @ngdoc function
126   * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicator
127   * @methodOf pascalprecht.translate.$translateProvider
128   *
129   * @description
130   * Sets an indicator which is used when a translation isn't found. E.g. when
131   * setting the indicator as 'X' and one tries to translate a translation id
132   * called `NOT_FOUND`, this will result in `X NOT_FOUND X`.
133   *
134   * Internally this methods sets a left indicator and a right indicator using
135   * `$translateProvider.translationNotFoundIndicatorLeft()` and
136   * `$translateProvider.translationNotFoundIndicatorRight()`.
137   *
138   * **Note**: These methods automatically add a whitespace between the indicators
139   * and the translation id.
140   *
141   * @param {string} indicator An indicator, could be any string.
142   */
143this.translationNotFoundIndicator=function(a){return this.translationNotFoundIndicatorLeft(a),this.translationNotFoundIndicatorRight(a),this},/**
144   * ngdoc function
145   * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
146   * @methodOf pascalprecht.translate.$translateProvider
147   *
148   * @description
149   * Sets an indicator which is used when a translation isn't found left to the
150   * translation id.
151   *
152   * @param {string} indicator An indicator.
153   */
154this.translationNotFoundIndicatorLeft=function(a){return a?(q=a,this):q},/**
155   * ngdoc function
156   * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
157   * @methodOf pascalprecht.translate.$translateProvider
158   *
159   * @description
160   * Sets an indicator which is used when a translation isn't found right to the
161   * translation id.
162   *
163   * @param {string} indicator An indicator.
164   */
165this.translationNotFoundIndicatorRight=function(a){return a?(r=a,this):r},/**
166   * @ngdoc function
167   * @name pascalprecht.translate.$translateProvider#fallbackLanguage
168   * @methodOf pascalprecht.translate.$translateProvider
169   *
170   * @description
171   * Tells the module which of the registered translation tables to use when missing translations
172   * at initial startup by passing a language key. Similar to `$translateProvider#use`
173   * only that it says which language to **fallback**.
174   *
175   * @param {string||array} langKey A language key.
176   *
177   */
178this.fallbackLanguage=function(a){return Q(a),this};var Q=function(a){return a?(angular.isString(a)?(h=!0,g=[a]):angular.isArray(a)&&(h=!1,g=a),angular.isString(e)&&K(g,e)<0&&g.push(e),this):h?g[0]:g};/**
179   * @ngdoc function
180   * @name pascalprecht.translate.$translateProvider#use
181   * @methodOf pascalprecht.translate.$translateProvider
182   *
183   * @description
184   * Set which translation table to use for translation by given language key. When
185   * trying to 'use' a language which isn't provided, it'll throw an error.
186   *
187   * You actually don't have to use this method since `$translateProvider#preferredLanguage`
188   * does the job too.
189   *
190   * @param {string} langKey A language key.
191   */
192this.use=function(a){if(a){if(!u[a]&&!o)
193// only throw an error, when not loading translation data asynchronously
194throw new Error("$translateProvider couldn't find translationTable for langKey: '"+a+"'");return i=a,this}return i},/**
195   * @ngdoc function
196   * @name pascalprecht.translate.$translateProvider#resolveClientLocale
197   * @methodOf pascalprecht.translate.$translateProvider
198   *
199   * @description
200   * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
201   *
202   * @returns {string} the current client/browser language key
203   */
204this.resolveClientLocale=function(){return J()};/**
205   * @ngdoc function
206   * @name pascalprecht.translate.$translateProvider#storageKey
207   * @methodOf pascalprecht.translate.$translateProvider
208   *
209   * @description
210   * Tells the module which key must represent the choosed language by a user in the storage.
211   *
212   * @param {string} key A key for the storage.
213   */
214var R=function(a){return a?(w=a,this):l?l+w:w};this.storageKey=R,/**
215   * @ngdoc function
216   * @name pascalprecht.translate.$translateProvider#useUrlLoader
217   * @methodOf pascalprecht.translate.$translateProvider
218   *
219   * @description
220   * Tells angular-translate to use `$translateUrlLoader` extension service as loader.
221   *
222   * @param {string} url Url
223   * @param {Object=} options Optional configuration object
224   */
225this.useUrlLoader=function(a,b){return this.useLoader("$translateUrlLoader",angular.extend({url:a},b))},/**
226   * @ngdoc function
227   * @name pascalprecht.translate.$translateProvider#useStaticFilesLoader
228   * @methodOf pascalprecht.translate.$translateProvider
229   *
230   * @description
231   * Tells angular-translate to use `$translateStaticFilesLoader` extension service as loader.
232   *
233   * @param {Object=} options Optional configuration object
234   */
235this.useStaticFilesLoader=function(a){return this.useLoader("$translateStaticFilesLoader",a)},/**
236   * @ngdoc function
237   * @name pascalprecht.translate.$translateProvider#useLoader
238   * @methodOf pascalprecht.translate.$translateProvider
239   *
240   * @description
241   * Tells angular-translate to use any other service as loader.
242   *
243   * @param {string} loaderFactory Factory name to use
244   * @param {Object=} options Optional configuration object
245   */
246this.useLoader=function(a,b){return o=a,p=b||{},this},/**
247   * @ngdoc function
248   * @name pascalprecht.translate.$translateProvider#useLocalStorage
249   * @methodOf pascalprecht.translate.$translateProvider
250   *
251   * @description
252   * Tells angular-translate to use `$translateLocalStorage` service as storage layer.
253   *
254   */
255this.useLocalStorage=function(){return this.useStorage("$translateLocalStorage")},/**
256   * @ngdoc function
257   * @name pascalprecht.translate.$translateProvider#useCookieStorage
258   * @methodOf pascalprecht.translate.$translateProvider
259   *
260   * @description
261   * Tells angular-translate to use `$translateCookieStorage` service as storage layer.
262   */
263this.useCookieStorage=function(){return this.useStorage("$translateCookieStorage")},/**
264   * @ngdoc function
265   * @name pascalprecht.translate.$translateProvider#useStorage
266   * @methodOf pascalprecht.translate.$translateProvider
267   *
268   * @description
269   * Tells angular-translate to use custom service as storage layer.
270   */
271this.useStorage=function(a){return k=a,this},/**
272   * @ngdoc function
273   * @name pascalprecht.translate.$translateProvider#storagePrefix
274   * @methodOf pascalprecht.translate.$translateProvider
275   *
276   * @description
277   * Sets prefix for storage key.
278   *
279   * @param {string} prefix Storage key prefix
280   */
281this.storagePrefix=function(a){return a?(l=a,this):a},/**
282   * @ngdoc function
283   * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandlerLog
284   * @methodOf pascalprecht.translate.$translateProvider
285   *
286   * @description
287   * Tells angular-translate to use built-in log handler when trying to translate
288   * a translation Id which doesn't exist.
289   *
290   * This is actually a shortcut method for `useMissingTranslationHandler()`.
291   *
292   */
293this.useMissingTranslationHandlerLog=function(){return this.useMissingTranslationHandler("$translateMissingTranslationHandlerLog")},/**
294   * @ngdoc function
295   * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandler
296   * @methodOf pascalprecht.translate.$translateProvider
297   *
298   * @description
299   * Expects a factory name which later gets instantiated with `$injector`.
300   * This method can be used to tell angular-translate to use a custom
301   * missingTranslationHandler. Just build a factory which returns a function
302   * and expects a translation id as argument.
303   *
304   * Example:
305   * <pre>
306   *  app.config(function ($translateProvider) {
307   *    $translateProvider.useMissingTranslationHandler('customHandler');
308   *  });
309   *
310   *  app.factory('customHandler', function (dep1, dep2) {
311   *    return function (translationId) {
312   *      // something with translationId and dep1 and dep2
313   *    };
314   *  });
315   * </pre>
316   *
317   * @param {string} factory Factory name
318   */
319this.useMissingTranslationHandler=function(a){return m=a,this},/**
320   * @ngdoc function
321   * @name pascalprecht.translate.$translateProvider#usePostCompiling
322   * @methodOf pascalprecht.translate.$translateProvider
323   *
324   * @description
325   * If post compiling is enabled, all translated values will be processed
326   * again with AngularJS' $compile.
327   *
328   * Example:
329   * <pre>
330   *  app.config(function ($translateProvider) {
331   *    $translateProvider.usePostCompiling(true);
332   *  });
333   * </pre>
334   *
335   * @param {string} factory Factory name
336   */
337this.usePostCompiling=function(a){return z=!!a,this},/**
338   * @ngdoc function
339   * @name pascalprecht.translate.$translateProvider#forceAsyncReload
340   * @methodOf pascalprecht.translate.$translateProvider
341   *
342   * @description
343   * If force async reload is enabled, async loader will always be called
344   * even if $translationTable already contains the language key, adding
345   * possible new entries to the $translationTable.
346   *
347   * Example:
348   * <pre>
349   *  app.config(function ($translateProvider) {
350   *    $translateProvider.forceAsyncReload(true);
351   *  });
352   * </pre>
353   *
354   * @param {boolean} value - valid values are true or false
355   */
356this.forceAsyncReload=function(a){return A=!!a,this},/**
357   * @ngdoc function
358   * @name pascalprecht.translate.$translateProvider#uniformLanguageTag
359   * @methodOf pascalprecht.translate.$translateProvider
360   *
361   * @description
362   * Tells angular-translate which language tag should be used as a result when determining
363   * the current browser language.
364   *
365   * This setting must be set before invoking {@link pascalprecht.translate.$translateProvider#methods_determinePreferredLanguage determinePreferredLanguage()}.
366   *
367   * <pre>
368   * $translateProvider
369   *   .uniformLanguageTag('bcp47')
370   *   .determinePreferredLanguage()
371   * </pre>
372   *
373   * The resolver currently supports:
374   * * default
375   *     (traditionally: hyphens will be converted into underscores, i.e. en-US => en_US)
376   *     en-US => en_US
377   *     en_US => en_US
378   *     en-us => en_us
379   * * java
380   *     like default, but the second part will be always in uppercase
381   *     en-US => en_US
382   *     en_US => en_US
383   *     en-us => en_US
384   * * BCP 47 (RFC 4646 & 4647)
385   *     en-US => en-US
386   *     en_US => en-US
387   *     en-us => en-US
388   *
389   * See also:
390   * * http://en.wikipedia.org/wiki/IETF_language_tag
391   * * http://www.w3.org/International/core/langtags/
392   * * http://tools.ietf.org/html/bcp47
393   *
394   * @param {string|object} options - options (or standard)
395   * @param {string} options.standard - valid values are 'default', 'bcp47', 'java'
396   */
397this.uniformLanguageTag=function(a){return a?angular.isString(a)&&(a={standard:a}):a={},F=a.standard,this},/**
398   * @ngdoc function
399   * @name pascalprecht.translate.$translateProvider#determinePreferredLanguage
400   * @methodOf pascalprecht.translate.$translateProvider
401   *
402   * @description
403   * Tells angular-translate to try to determine on its own which language key
404   * to set as preferred language. When `fn` is given, angular-translate uses it
405   * to determine a language key, otherwise it uses the built-in `getLocale()`
406   * method.
407   *
408   * The `getLocale()` returns a language key in the format `[lang]_[country]` or
409   * `[lang]` depending on what the browser provides.
410   *
411   * Use this method at your own risk, since not all browsers return a valid
412   * locale (see {@link pascalprecht.translate.$translateProvider#methods_uniformLanguageTag uniformLanguageTag()}).
413   *
414   * @param {Function=} fn Function to determine a browser's locale
415   */
416this.determinePreferredLanguage=function(a){var b=a&&angular.isFunction(a)?a():J();return e=v.length?M(b)||b:b,this},/**
417   * @ngdoc function
418   * @name pascalprecht.translate.$translateProvider#registerAvailableLanguageKeys
419   * @methodOf pascalprecht.translate.$translateProvider
420   *
421   * @description
422   * Registers a set of language keys the app will work with. Use this method in
423   * combination with
424   * {@link pascalprecht.translate.$translateProvider#determinePreferredLanguage determinePreferredLanguage}.
425   * When available languages keys are registered, angular-translate
426   * tries to find the best fitting language key depending on the browsers locale,
427   * considering your language key convention.
428   *
429   * @param {object} languageKeys Array of language keys the your app will use
430   * @param {object=} aliases Alias map.
431   */
432this.registerAvailableLanguageKeys=function(a,b){return a?(v=a,b&&(f=b),this):v},/**
433   * @ngdoc function
434   * @name pascalprecht.translate.$translateProvider#useLoaderCache
435   * @methodOf pascalprecht.translate.$translateProvider
436   *
437   * @description
438   * Registers a cache for internal $http based loaders.
439   * {@link pascalprecht.translate.$translationCache $translationCache}.
440   * When false the cache will be disabled (default). When true or undefined
441   * the cache will be a default (see $cacheFactory). When an object it will
442   * be treat as a cache object itself: the usage is $http({cache: cache})
443   *
444   * @param {object} cache boolean, string or cache-object
445   */
446this.useLoaderCache=function(a){
447// disable cache
448// enable cache using AJS defaults
449// enable cache using default
450// enable cache using given one (see $cacheFactory)
451return a===!1?s=void 0:a===!0?s=!0:"undefined"==typeof a?s="$translationCache":a&&(s=a),this},/**
452   * @ngdoc function
453   * @name pascalprecht.translate.$translateProvider#directivePriority
454   * @methodOf pascalprecht.translate.$translateProvider
455   *
456   * @description
457   * Sets the default priority of the translate directive. The standard value is `0`.
458   * Calling this function without an argument will return the current value.
459   *
460   * @param {number} priority for the translate-directive
461   */
462this.directivePriority=function(a){
463// setter with chaining
464return void 0===a?D:(D=a,this)},/**
465   * @ngdoc function
466   * @name pascalprecht.translate.$translateProvider#statefulFilter
467   * @methodOf pascalprecht.translate.$translateProvider
468   *
469   * @description
470   * Since AngularJS 1.3, filters which are not stateless (depending at the scope)
471   * have to explicit define this behavior.
472   * Sets whether the translate filter should be stateful or stateless. The standard value is `true`
473   * meaning being stateful.
474   * Calling this function without an argument will return the current value.
475   *
476   * @param {boolean} state - defines the state of the filter
477   */
478this.statefulFilter=function(a){
479// setter with chaining
480return void 0===a?E:(E=a,this)},/**
481   * @ngdoc function
482   * @name pascalprecht.translate.$translateProvider#postProcess
483   * @methodOf pascalprecht.translate.$translateProvider
484   *
485   * @description
486   * The post processor will be intercept right after the translation result. It can modify the result.
487   *
488   * @param {object} fn Function or service name (string) to be called after the translation value has been set / resolved. The function itself will enrich every value being processed and then continue the normal resolver process
489   */
490this.postProcess=function(a){return t=a?a:void 0,this},/**
491   * @ngdoc object
492   * @name pascalprecht.translate.$translate
493   * @requires $interpolate
494   * @requires $log
495   * @requires $rootScope
496   * @requires $q
497   *
498   * @description
499   * The `$translate` service is the actual core of angular-translate. It expects a translation id
500   * and optional interpolate parameters to translate contents.
501   *
502   * <pre>
503   *  $translate('HEADLINE_TEXT').then(function (translation) {
504   *    $scope.translatedText = translation;
505   *  });
506   * </pre>
507   *
508   * @param {string|array} translationId A token which represents a translation id
509   *                                     This can be optionally an array of translation ids which
510   *                                     results that the function returns an object where each key
511   *                                     is the translation id and the value the translation.
512   * @param {object=} interpolateParams An object hash for dynamic values
513   * @param {string} interpolationId The id of the interpolation to use
514   * @param {string} forceLanguage A language to be used instead of the current language
515   * @returns {object} promise
516   */
517this.$get=["$log","$injector","$rootScope","$q",function(a,b,c,d){var f,l,F,G=b.get(n||"$translateDefaultInterpolation"),I=!1,S={},T={},U=function(a,b,c,h,j){!i&&e&&(i=e);var m=j&&j!==i?// we don't want to re-negotiate $uses
518M(j)||j:i;
519// Duck detection: If the first argument is an array, a bunch of translations was requested.
520// The result is an object.
521if(
522// Check forceLanguage is present
523j&&ja(j),angular.isArray(a)){
vendor: 4,974 bytes, lines 524-581
524// Inspired by Q.allSettled by Kris Kowal
525// https://github.com/kriskowal/q/blob/b0fa72980717dc202ffc3cbf03b936e10ebbb9d7/q.js#L1553-1563
526// This transforms all promises regardless resolved or rejected
527var n=function(a){for(var e={},f=[],g=function(a){var f=d.defer(),g=function(b){e[a]=b,f.resolve([a,b])};
528// we don't care whether the promise was resolved or rejected; just store the values
529return U(a,b,c,h,j).then(g,g),f.promise},i=0,k=a.length;k>i;i++)f.push(g(a[i]));
530// wait for all (including storing to results)
531return d.all(f).then(function(){
532// return the results
533return e})};return n(a)}var o=d.defer();
534// trim off any whitespace
535a&&(a=L.apply(a));var p=function(){var a=e?T[e]:T[m];if(l=0,k&&!a){
536// looks like there's no pending promise for $preferredLanguage or
537// $uses. Maybe there's one pending for a language that comes from
538// storage.
539var b=f.get(w);if(a=T[b],g&&g.length){var c=K(g,b);
540// maybe the language from storage is also defined as fallback language
541// we increase the fallback language index to not search in that language
542// as fallback, since it's probably the first used language
543// in that case the index starts after the first element
544l=0===c?1:0,
545// but we can make sure to ALWAYS fallback to preferred language at least
546K(g,e)<0&&g.push(e)}}return a}();if(p){var q=function(){
547// $uses may have changed while waiting
548j||(m=i),fa(a,b,c,h,m).then(o.resolve,o.reject)};q.displayName="promiseResolved",p["finally"](q)}else
549// no promise to wait for? okay. Then there's no loader registered
550// nor is a one pending for language that comes from storage.
551// We can just translate.
552fa(a,b,c,h,m).then(o.resolve,o.reject);return o.promise},V=function(a){
553// applying notFoundIndicators
554return q&&(a=[q,a].join(" ")),r&&(a=[a,r].join(" ")),a},W=function(a){i=a,k&&f.put(U.storageKey(),i),c.$emit("$translateChangeSuccess",{language:a}),G.setLocale(i);var b=function(a,b){S[b].setLocale(i)};b.displayName="eachInterpolatorLocaleSetter",
555// inform all others too!
556angular.forEach(S,b),c.$emit("$translateChangeEnd",{language:a})},X=function(a){if(!a)throw"No language key specified for loading.";var e=d.defer();c.$emit("$translateLoadingStart",{language:a}),I=!0;var f=s;"string"==typeof f&&(
557// getting on-demand instance of loader
558f=b.get(f));var g=angular.extend({},p,{key:a,$http:angular.extend({},{cache:f},p.$http)}),h=function(b){var d={};c.$emit("$translateLoadingSuccess",{language:a}),angular.isArray(b)?angular.forEach(b,function(a){angular.extend(d,O(a))}):angular.extend(d,O(b)),I=!1,e.resolve({key:a,table:d}),c.$emit("$translateLoadingEnd",{language:a})};h.displayName="onLoaderSuccess";var i=function(a){c.$emit("$translateLoadingError",{language:a}),e.reject(a),c.$emit("$translateLoadingEnd",{language:a})};return i.displayName="onLoaderError",b.get(o)(g).then(h,i),e.promise};if(k&&(f=b.get(k),!f.get||!f.put))throw new Error("Couldn't use storage '"+k+"', missing get() or put() method!");
559// if we have additional interpolations that were added via
560// $translateProvider.addInterpolation(), we have to map'em
561if(x.length){var Y=function(a){var c=b.get(a);
562// setting initial locale for each interpolation service
563c.setLocale(e||i),
564// make'em recognizable through id
565S[c.getInterpolationIdentifier()]=c};Y.displayName="interpolationFactoryAdder",angular.forEach(x,Y)}/**
566       * @name getTranslationTable
567       * @private
568       *
569       * @description
570       * Returns a promise that resolves to the translation table
571       * or is rejected if an error occurred.
572       *
573       * @param langKey
574       * @returns {Q.promise}
575       */
576var Z=function(a){var b=d.defer();if(Object.prototype.hasOwnProperty.call(u,a))b.resolve(u[a]);else if(T[a]){var c=function(a){N(a.key,a.table),b.resolve(a.table)};c.displayName="translationTableResolver",T[a].then(c,b.reject)}else b.reject();return b.promise},$=function(a,b,c,e){var f=d.defer(),g=function(d){if(Object.prototype.hasOwnProperty.call(d,b)){e.setLocale(a);var g=d[b];if("@:"===g.substr(0,2))$(a,g.substr(2),c,e).then(f.resolve,f.reject);else{var h=e.interpolate(d[b],c);h=ia(b,d[b],h,c,a),f.resolve(h)}e.setLocale(i)}else f.reject()};return g.displayName="fallbackTranslationResolver",Z(a).then(g,f.reject),f.promise},_=function(a,b,c,d){var e,f=u[a];if(f&&Object.prototype.hasOwnProperty.call(f,b)){if(d.setLocale(a),e=d.interpolate(f[b],c),"@:"===e.substr(0,2))return _(a,e.substr(2),c,d);d.setLocale(i)}return e},aa=function(a,c,d){
577// If we have a handler factory - we might also call it here to determine if it provides
578// a default text for a translationid that can't be found anywhere in our tables
579if(m){var e=b.get(m)(a,i,c,d);return void 0!==e?e:a}return a},ba=function(a,b,c,e,f){var h=d.defer();if(a<g.length){var i=g[a];$(i,b,c,e).then(function(a){h.resolve(a)},function(){
580// Look in the next fallback language for a translation.
581// It delays the resolving by passing another promise to resolve.
582return ba(a+1,b,c,e,f).then(h.resolve,h.reject)})}else
583// No translation found in any fallback language
584// if a default translation text is set in the directive, then return this as a result
585f?h.resolve(f):
586// if no default translation is set and an error handler is defined, send it to the handler
587// and then return the result
588m?h.resolve(aa(b,c)):h.reject(aa(b,c));return h.promise},ca=function(a,b,c,d){var e;if(a<g.length){var f=g[a];e=_(f,b,c,d),e||(e=ca(a+1,b,c,d))}return e},da=function(a,b,c,d){
589// Start with the fallbackLanguage with index 0
590return ba(F>0?F:l,a,b,c,d)},ea=function(a,b,c){
591// Start with the fallbackLanguage with index 0
592return ca(F>0?F:l,a,b,c)},fa=function(a,b,c,e,f){var h=d.defer(),i=f?u[f]:u,j=c?S[c]:G;
593// if the translation id exists, we can just interpolate it
594if(i&&Object.prototype.hasOwnProperty.call(i,a)){var k=i[a];
595// If using link, rerun $translate with linked translationId and return it
596if("@:"===k.substr(0,2))U(k.substr(2),b,c,e,f).then(h.resolve,h.reject);else{
597//
598var l=j.interpolate(k,b);l=ia(a,k,l,b,f),h.resolve(l)}}else{var n;
599// for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
600m&&!I&&(n=aa(a,b,e)),
601// since we couldn't translate the inital requested translation id,
602// we try it now with one or more fallback languages, if fallback language(s) is
603// configured.
604f&&g&&g.length?da(a,b,j,e).then(function(a){h.resolve(a)},function(a){h.reject(V(a))}):m&&!I&&n?
605// looks like the requested translation id doesn't exists.
606// Now, if there is a registered handler for missing translations and no
607// asyncLoader is pending, we execute the handler
608e?h.resolve(e):h.resolve(n):e?h.resolve(e):h.reject(V(a))}return h.promise},ga=function(a,b,c,d){var e,f=d?u[d]:u,h=G;
609// if the translation id exists, we can just interpolate it
610if(
611// if the interpolation id exists use custom interpolator
612S&&Object.prototype.hasOwnProperty.call(S,c)&&(h=S[c]),f&&Object.prototype.hasOwnProperty.call(f,a)){var i=f[a];
613// If using link, rerun $translate with linked translationId and return it
614e="@:"===i.substr(0,2)?ga(i.substr(2),b,c,d):h.interpolate(i,b)}else{var j;
615// for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
616m&&!I&&(j=aa(a,b)),
617// since we couldn't translate the inital requested translation id,
618// we try it now with one or more fallback languages, if fallback language(s) is
619// configured.
620d&&g&&g.length?(l=0,e=ea(a,b,h)):e=m&&!I&&j?j:V(a)}return e},ha=function(a){j===a&&(j=void 0),T[a]=void 0},ia=function(a,c,d,e,f){var g=t;
621// getting on-demand instance
622return g&&("string"==typeof g&&(g=b.get(g)),g)?g(a,c,d,e,f):d},ja=function(a){u[a]||!o||T[a]||(T[a]=X(a).then(function(a){N(a.key,a.table)}))};/**
623       * @ngdoc function
624       * @name pascalprecht.translate.$translate#preferredLanguage
625       * @methodOf pascalprecht.translate.$translate
626       *
627       * @description
628       * Returns the language key for the preferred language.
629       *
630       * @param {string} langKey language String or Array to be used as preferredLanguage (changing at runtime)
631       *
632       * @return {string} preferred language key
633       */
634U.preferredLanguage=function(a){return a&&P(a),e},/**
635       * @ngdoc function
636       * @name pascalprecht.translate.$translate#cloakClassName
637       * @methodOf pascalprecht.translate.$translate
638       *
639       * @description
640       * Returns the configured class name for `translate-cloak` directive.
641       *
642       * @return {string} cloakClassName
643       */
644U.cloakClassName=function(){return y},/**
645       * @ngdoc function
646       * @name pascalprecht.translate.$translate#nestedObjectDelimeter
647       * @methodOf pascalprecht.translate.$translate
648       *
649       * @description
650       * Returns the configured delimiter for nested namespaces.
651       *
652       * @return {string} nestedObjectDelimeter
653       */
654U.nestedObjectDelimeter=function(){return B},/**
655       * @ngdoc function
656       * @name pascalprecht.translate.$translate#fallbackLanguage
657       * @methodOf pascalprecht.translate.$translate
658       *
659       * @description
660       * Returns the language key for the fallback languages or sets a new fallback stack.
661       *
662       * @param {string=} langKey language String or Array of fallback languages to be used (to change stack at runtime)
663       *
664       * @return {string||array} fallback language key
665       */
666U.fallbackLanguage=function(a){if(void 0!==a&&null!==a){
667// as we might have an async loader initiated and a new translation language might have been defined
668// we need to add the promise to the stack also. So - iterate.
669if(Q(a),o&&g&&g.length)for(var b=0,c=g.length;c>b;b++)T[g[b]]||(T[g[b]]=X(g[b]));U.use(U.use())}return h?g[0]:g},/**
670       * @ngdoc function
671       * @name pascalprecht.translate.$translate#useFallbackLanguage
672       * @methodOf pascalprecht.translate.$translate
673       *
674       * @description
675       * Sets the first key of the fallback language stack to be used for translation.
676       * Therefore all languages in the fallback array BEFORE this key will be skipped!
677       *
678       * @param {string=} langKey Contains the langKey the iteration shall start with. Set to false if you want to
679       * get back to the whole stack
680       */
681U.useFallbackLanguage=function(a){if(void 0!==a&&null!==a)if(a){var b=K(g,a);b>-1&&(F=b)}else F=0},/**
682       * @ngdoc function
683       * @name pascalprecht.translate.$translate#proposedLanguage
684       * @methodOf pascalprecht.translate.$translate
685       *
686       * @description
687       * Returns the language key of language that is currently loaded asynchronously.
688       *
689       * @return {string} language key
690       */
691U.proposedLanguage=function(){return j},/**
692       * @ngdoc function
693       * @name pascalprecht.translate.$translate#storage
694       * @methodOf pascalprecht.translate.$translate
695       *
696       * @description
697       * Returns registered storage.
698       *
699       * @return {object} Storage
700       */
701U.storage=function(){return f},/**
702       * @ngdoc function
703       * @name pascalprecht.translate.$translate#negotiateLocale
704       * @methodOf pascalprecht.translate.$translate
705       *
706       * @description
707       * Returns a language key based on available languages and language aliases. If a
708       * language key cannot be resolved, returns undefined.
709       *
710       * If no or a falsy key is given, returns undefined.
711       *
712       * @param {string} [key] Language key
713       * @return {string|undefined} Language key or undefined if no language key is found.
714       */
715U.negotiateLocale=M,/**
716       * @ngdoc function
717       * @name pascalprecht.translate.$translate#use
718       * @methodOf pascalprecht.translate.$translate
719       *
720       * @description
721       * Tells angular-translate which language to use by given language key. This method is
722       * used to change language at runtime. It also takes care of storing the language
723       * key in a configured store to let your app remember the choosed language.
724       *
725       * When trying to 'use' a language which isn't available it tries to load it
726       * asynchronously with registered loaders.
727       *
728       * Returns promise object with loaded language file data or string of the currently used language.
729       *
730       * If no or a falsy key is given it returns the currently used language key.
731       * The returned string will be ```undefined``` if setting up $translate hasn't finished.
732       * @example
733       * $translate.use("en_US").then(function(data){
734       *   $scope.text = $translate("HELLO");
735       * });
736       *
737       * @param {string} [key] Language key
738       * @return {object|string} Promise with loaded language data or the language key if a falsy param was given.
739       */
740U.use=function(a){if(!a)return i;var b=d.defer();c.$emit("$translateChangeStart",{language:a});
741// Try to get the aliased language key
742var e=M(a);
743// Ensure only registered language keys will be loaded
744// Ensure only registered language keys will be loaded
745// if there isn't a translation table for the language we've requested,
746// we load it asynchronously
747// we are already loading this asynchronously
748// resolve our new deferred when the old langPromise is resolved
749return v.length>0&&!e?d.reject(a):(e&&(a=e),j=a,!A&&u[a]||!o||T[a]?T[a]?T[a].then(function(a){return j===a.key&&W(a.key),b.resolve(a.key),a},function(a){return!i&&g&&g.length>0?U.use(g[0]).then(b.resolve,b.reject):b.reject(a)}):(b.resolve(a),W(a)):(T[a]=X(a).then(function(c){return N(c.key,c.table),b.resolve(c.key),j===a&&W(c.key),c},function(a){return c.$emit("$translateChangeError",{language:a}),b.reject(a),c.$emit("$translateChangeEnd",{language:a}),d.reject(a)}),T[a]["finally"](function(){ha(a)})),b.promise)},/**
750       * @ngdoc function
751       * @name pascalprecht.translate.$translate#resolveClientLocale
752       * @methodOf pascalprecht.translate.$translate
753       *
754       * @description
755       * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
756       *
757       * @returns {string} the current client/browser language key
758       */
759U.resolveClientLocale=function(){return J()},/**
760       * @ngdoc function
761       * @name pascalprecht.translate.$translate#storageKey
762       * @methodOf pascalprecht.translate.$translate
763       *
764       * @description
765       * Returns the key for the storage.
766       *
767       * @return {string} storage key
768       */
769U.storageKey=function(){return R()},/**
770       * @ngdoc function
771       * @name pascalprecht.translate.$translate#isPostCompilingEnabled
772       * @methodOf pascalprecht.translate.$translate
773       *
774       * @description
775       * Returns whether post compiling is enabled or not
776       *
777       * @return {bool} storage key
778       */
779U.isPostCompilingEnabled=function(){return z},/**
780       * @ngdoc function
781       * @name pascalprecht.translate.$translate#isForceAsyncReloadEnabled
782       * @methodOf pascalprecht.translate.$translate
783       *
784       * @description
785       * Returns whether force async reload is enabled or not
786       *
787       * @return {boolean} forceAsyncReload value
788       */
789U.isForceAsyncReloadEnabled=function(){return A},/**
790       * @ngdoc function
791       * @name pascalprecht.translate.$translate#refresh
792       * @methodOf pascalprecht.translate.$translate
793       *
794       * @description
795       * Refreshes a translation table pointed by the given langKey. If langKey is not specified,
796       * the module will drop all existent translation tables and load new version of those which
797       * are currently in use.
798       *
799       * Refresh means that the module will drop target translation table and try to load it again.
800       *
801       * In case there are no loaders registered the refresh() method will throw an Error.
802       *
803       * If the module is able to refresh translation tables refresh() method will broadcast
804       * $translateRefreshStart and $translateRefreshEnd events.
805       *
806       * @example
807       * // this will drop all currently existent translation tables and reload those which are
808       * // currently in use
809       * $translate.refresh();
810       * // this will refresh a translation table for the en_US language
811       * $translate.refresh('en_US');
812       *
813       * @param {string} langKey A language key of the table, which has to be refreshed
814       *
815       * @return {promise} Promise, which will be resolved in case a translation tables refreshing
816       * process is finished successfully, and reject if not.
817       */
818U.refresh=function(a){function b(){f.resolve(),c.$emit("$translateRefreshEnd",{language:a})}function e(){f.reject(),c.$emit("$translateRefreshEnd",{language:a})}if(!o)throw new Error("Couldn't refresh translation table, no loader registered!");var f=d.defer();if(c.$emit("$translateRefreshStart",{language:a}),a)if(u[a]){var h=function(c){N(c.key,c.table),a===i&&W(i),b()};h.displayName="refreshPostProcessor",X(a).then(h,e)}else e();else{
819// if there's no language key specified we refresh ALL THE THINGS!
820var j=[],k={};
821// reload registered fallback languages
822if(g&&g.length)for(var l=0,m=g.length;m>l;l++)j.push(X(g[l])),k[g[l]]=!0;
823// reload currently used language
824i&&!k[i]&&j.push(X(i));var n=function(a){u={},angular.forEach(a,function(a){N(a.key,a.table)}),i&&W(i),b()};n.displayName="refreshPostProcessor",d.all(j).then(n,e)}return f.promise},/**
825       * @ngdoc function
826       * @name pascalprecht.translate.$translate#instant
827       * @methodOf pascalprecht.translate.$translate
828       *
829       * @description
830       * Returns a translation instantly from the internal state of loaded translation. All rules
831       * regarding the current language, the preferred language of even fallback languages will be
832       * used except any promise handling. If a language was not found, an asynchronous loading
833       * will be invoked in the background.
834       *
835       * @param {string|array} translationId A token which represents a translation id
836       *                                     This can be optionally an array of translation ids which
837       *                                     results that the function's promise returns an object where
838       *                                     each key is the translation id and the value the translation.
839       * @param {object} interpolateParams Params
840       * @param {string} interpolationId The id of the interpolation to use
841       * @param {string} forceLanguage A language to be used instead of the current language
842       *
843       * @return {string|object} translation
844       */
845U.instant=function(a,b,c,d){
846// we don't want to re-negotiate $uses
847var f=d&&d!==i?// we don't want to re-negotiate $uses
848M(d)||d:i;
849// Detect undefined and null values to shorten the execution and prevent exceptions
850if(null===a||angular.isUndefined(a))return a;
851// Duck detection: If the first argument is an array, a bunch of translations was requested.
852// The result is an object.
853if(
854// Check forceLanguage is present
855d&&ja(d),angular.isArray(a)){for(var h={},j=0,k=a.length;k>j;j++)h[a[j]]=U.instant(a[j],b,c,d);return h}
856// We discarded unacceptable values. So we just need to verify if translationId is empty String
857if(angular.isString(a)&&a.length<1)return a;
858// trim off any whitespace
859a&&(a=L.apply(a));var l,n=[];e&&n.push(e),f&&n.push(f),g&&g.length&&(n=n.concat(g));for(var o=0,p=n.length;p>o;o++){var s=n[o];if(u[s]&&"undefined"!=typeof u[s][a]&&(l=ga(a,b,c,f)),"undefined"!=typeof l)break}
860// Return translation of default interpolator if not found anything.
861return l||""===l||(q||r?l=V(a):(l=G.interpolate(a,b),m&&!I&&(l=aa(a,b)))),l},/**
862       * @ngdoc function
863       * @name pascalprecht.translate.$translate#versionInfo
864       * @methodOf pascalprecht.translate.$translate
865       *
vendor: 11,463 bytes, lines 866-1064
866       * @description
867       * Returns the current version information for the angular-translate library
868       *
869       * @return {string} angular-translate version
870       */
871U.versionInfo=function(){return H},/**
872       * @ngdoc function
873       * @name pascalprecht.translate.$translate#loaderCache
874       * @methodOf pascalprecht.translate.$translate
875       *
876       * @description
877       * Returns the defined loaderCache.
878       *
879       * @return {boolean|string|object} current value of loaderCache
880       */
881U.loaderCache=function(){return s},
882// internal purpose only
883U.directivePriority=function(){return D},
884// internal purpose only
885U.statefulFilter=function(){return E},/**
886       * @ngdoc function
887       * @name pascalprecht.translate.$translate#isReady
888       * @methodOf pascalprecht.translate.$translate
889       *
890       * @description
891       * Returns whether the service is "ready" to translate (i.e. loading 1st language).
892       *
893       * See also {@link pascalprecht.translate.$translate#methods_onReady onReady()}.
894       *
895       * @return {boolean} current value of ready
896       */
897U.isReady=function(){return C};var ka=d.defer();ka.promise.then(function(){C=!0}),/**
898       * @ngdoc function
899       * @name pascalprecht.translate.$translate#onReady
900       * @methodOf pascalprecht.translate.$translate
901       *
902       * @description
903       * Returns whether the service is "ready" to translate (i.e. loading 1st language).
904       *
905       * See also {@link pascalprecht.translate.$translate#methods_isReady isReady()}.
906       *
907       * @param {Function=} fn Function to invoke when service is ready
908       * @return {object} Promise resolved when service is ready
909       */
910U.onReady=function(a){var b=d.defer();return angular.isFunction(a)&&b.promise.then(a),C?b.resolve():ka.promise.then(b.resolve),b.promise},/**
911       * @ngdoc function
912       * @name pascalprecht.translate.$translate#getAvailableLanguageKeys
913       * @methodOf pascalprecht.translate.$translate
914       *
915       * @description
916       * This function simply returns the registered language keys being defined before in the config phase
917       * With this, an application can use the array to provide a language selection dropdown or similar
918       * without any additional effort
919       *
920       * @returns {object} returns the list of possibly registered language keys and mapping or null if not defined
921       */
922U.getAvailableLanguageKeys=function(){return v.length>0?v:null};
923// Whenever $translateReady is being fired, this will ensure the state of $isReady
924var la=c.$on("$translateReady",function(){ka.resolve(),la(),// one time only
925la=null}),ma=c.$on("$translateChangeEnd",function(){ka.resolve(),ma(),// one time only
926ma=null});if(o){
927// Also, if there are any fallback language registered, we start
928// loading them asynchronously as soon as we can.
929if(
930// If at least one async loader is defined and there are no
931// (default) translations available we should try to load them.
932angular.equals(u,{})&&U.use()&&U.use(U.use()),g&&g.length)for(var na=function(a){return N(a.key,a.table),c.$emit("$translateChangeEnd",{language:a.key}),a},oa=0,pa=g.length;pa>oa;oa++){var qa=g[oa];!A&&u[qa]||(T[qa]=X(qa).then(na))}}else c.$emit("$translateReady",{language:U.use()});return U}]}function d(a,b){"use strict";var c,d={},e="default";/**
933   * @ngdoc function
934   * @name pascalprecht.translate.$translateDefaultInterpolation#setLocale
935   * @methodOf pascalprecht.translate.$translateDefaultInterpolation
936   *
937   * @description
938   * Sets current locale (this is currently not use in this interpolation).
939   *
940   * @param {string} locale Language key or locale.
941   */
942/**
943   * @ngdoc function
944   * @name pascalprecht.translate.$translateDefaultInterpolation#getInterpolationIdentifier
945   * @methodOf pascalprecht.translate.$translateDefaultInterpolation
946   *
947   * @description
948   * Returns an identifier for this interpolation service.
949   *
950   * @returns {string} $identifier
951   */
952/**
953   * @deprecated will be removed in 3.0
954   * @see {@link pascalprecht.translate.$translateSanitization}
955   */
956/**
957   * @ngdoc function
958   * @name pascalprecht.translate.$translateDefaultInterpolation#interpolate
959   * @methodOf pascalprecht.translate.$translateDefaultInterpolation
960   *
961   * @description
962   * Interpolates given string agains given interpolate params using angulars
963   * `$interpolate` service.
964   *
965   * @returns {string} interpolated string.
966   */
967return d.setLocale=function(a){c=a},d.getInterpolationIdentifier=function(){return e},d.useSanitizeValueStrategy=function(a){return b.useStrategy(a),this},d.interpolate=function(c,d){d=d||{},d=b.sanitize(d,"params");var e=a(c)(d);return e=b.sanitize(e,"text")},d}function e(a,b,c,d,e,g){"use strict";/**
968   * @name trim
969   * @private
970   *
971   * @description
972   * trim polyfill
973   *
974   * @returns {string} The string stripped of whitespace from both ends
975   */
976var h=function(){return this.toString().replace(/^\s+|\s+$/g,"")};return{restrict:"AE",scope:!0,priority:a.directivePriority(),compile:function(b,i){var j=i.translateValues?i.translateValues:void 0,k=i.translateInterpolation?i.translateInterpolation:void 0,l=b[0].outerHTML.match(/translate-value-+/i),m="^(.*)("+c.startSymbol()+".*"+c.endSymbol()+")(.*)",n="^(.*)"+c.startSymbol()+"(.*)"+c.endSymbol()+"(.*)";return function(b,o,p){b.interpolateParams={},b.preText="",b.postText="",b.translateNamespace=f(b);var q={},r=function(a,c,d){
977// initially fetch all attributes if existing and fill the params
978if(
979// initial setup
980c.translateValues&&angular.extend(a,e(c.translateValues)(b.$parent)),l)for(var f in d)if(Object.prototype.hasOwnProperty.call(c,f)&&"translateValue"===f.substr(0,14)&&"translateValues"!==f){var g=angular.lowercase(f.substr(14,1))+f.substr(15);a[g]=d[f]}},s=function(a){if(
981// Remove any old watcher
982angular.isFunction(s._unwatchOld)&&(s._unwatchOld(),s._unwatchOld=void 0),angular.equals(a,"")||!angular.isDefined(a)){var d=h.apply(o.text()),e=d.match(m);
983// Interpolate translation id if required
984if(angular.isArray(e)){b.preText=e[1],b.postText=e[3],q.translate=c(e[2])(b.$parent);var f=d.match(n);angular.isArray(f)&&f[2]&&f[2].length&&(s._unwatchOld=b.$watch(f[2],function(a){q.translate=a,y()}))}else
985// do not assigne the translation id if it is empty.
986q.translate=d?d:void 0}else q.translate=a;y()},t=function(a){p.$observe(a,function(b){q[a]=b,y()})};
987// initial setup with values
988r(b.interpolateParams,p,i);var u=!0;p.$observe("translate",function(a){"undefined"==typeof a?
989// case of element "<translate>xyz</translate>"
990s(""):
991// case of regular attribute
992""===a&&u||(q.translate=a,y()),u=!1});for(var v in p)p.hasOwnProperty(v)&&"translateAttr"===v.substr(0,13)&&t(v);if(p.$observe("translateDefault",function(a){b.defaultText=a,y()}),j&&p.$observe("translateValues",function(a){a&&b.$parent.$watch(function(){angular.extend(b.interpolateParams,e(a)(b.$parent))})}),l){var w=function(a){p.$observe(a,function(c){var d=angular.lowercase(a.substr(14,1))+a.substr(15);b.interpolateParams[d]=c})};for(var x in p)Object.prototype.hasOwnProperty.call(p,x)&&"translateValue"===x.substr(0,14)&&"translateValues"!==x&&w(x)}
993// Master update function
994var y=function(){for(var a in q)q.hasOwnProperty(a)&&void 0!==q[a]&&z(a,q[a],b,b.interpolateParams,b.defaultText,b.translateNamespace)},z=function(b,c,d,e,f,g){c?(
995// if translation id starts with '.' and translateNamespace given, prepend namespace
996g&&"."===c.charAt(0)&&(c=g+c),a(c,e,k,f,d.translateLanguage).then(function(a){A(a,d,!0,b)},function(a){A(a,d,!1,b)})):
997// as an empty string cannot be translated, we can solve this using successful=false
998A(c,d,!1,b)},A=function(b,c,e,f){if(e||"undefined"!=typeof c.defaultText&&(b=c.defaultText),"translate"===f){
999// default translate into innerHTML
1000(e||!e&&"undefined"==typeof p.translateKeepContent)&&o.empty().append(c.preText+b+c.postText);var g=a.isPostCompilingEnabled(),h="undefined"!=typeof i.translateCompile,j=h&&"false"!==i.translateCompile;(g&&!h||j)&&d(o.contents())(c)}else{
1001// translate attribute
1002var k=p.$attr[f];"data-"===k.substr(0,5)&&(
1003// ensure html5 data prefix is stripped
1004k=k.substr(5)),k=k.substr(15),o.attr(k,b)}};(j||l||p.translateDefault)&&b.$watch("interpolateParams",y,!0);
1005// Replaced watcher on translateLanguage with event listener
1006var B=b.$on("translateLanguageChanged",y),C=g.$on("$translateChangeSuccess",y);
1007// ensure translation will be looked up at least one
1008o.text().length?s(p.translate?p.translate:""):p.translate&&
1009// ensure attribute will be not skipped
1010s(p.translate),y(),b.$on("$destroy",function(){B(),C()})}}}}/**
1011 * Returns the scope's namespace.
1012 * @private
1013 * @param scope
1014 * @returns {string}
1015 */
1016function f(a){"use strict";return a.translateNamespace?a.translateNamespace:a.$parent?f(a.$parent):void 0}function g(a,b){"use strict";return{compile:function(c){var d=function(){c.addClass(a.cloakClassName())},e=function(){c.removeClass(a.cloakClassName())};return a.onReady(function(){e()}),d(),function(c,f,g){g.translateCloak&&g.translateCloak.length&&(
1017// Register a watcher for the defined translation allowing a fine tuned cloak
1018g.$observe("translateCloak",function(b){a(b).then(e,d)}),
1019// Register for change events as this is being another indicicator revalidating the cloak)
1020b.$on("$translateChangeSuccess",function(){a(g.translateCloak).then(e,d)}))}}}}function h(){"use strict";return{restrict:"A",scope:!0,compile:function(){return{pre:function(a,b,c){a.translateNamespace=f(a),a.translateNamespace&&"."===c.translateNamespace.charAt(0)?a.translateNamespace+=c.translateNamespace:a.translateNamespace=c.translateNamespace}}}}}/**
1021 * Returns the scope's namespace.
1022 * @private
1023 * @param scope
1024 * @returns {string}
1025 */
1026function f(a){"use strict";return a.translateNamespace?a.translateNamespace:a.$parent?f(a.$parent):void 0}function i(){"use strict";return{restrict:"A",scope:!0,compile:function(){return function(a,b,c){c.$observe("translateLanguage",function(b){a.translateLanguage=b}),a.$watch("translateLanguage",function(){a.$broadcast("translateLanguageChanged")})}}}}function j(a,b){"use strict";var c=function(c,d,e,f){return angular.isObject(d)||(d=a(d)(this)),b.instant(c,d,e,f)};return b.statefulFilter()&&(c.$stateful=!0),c}function k(a){"use strict";return a("translations")}/**
1027 * @ngdoc overview
1028 * @name pascalprecht.translate
1029 *
1030 * @description
1031 * The main module which holds everything together.
1032 */
1033/**
1034 * @ngdoc object
1035 * @name pascalprecht.translate.$translateSanitizationProvider
1036 *
1037 * @description
1038 *
1039 * Configurations for $translateSanitization
1040 */
1041/**
1042 * @ngdoc object
1043 * @name pascalprecht.translate.$translateProvider
1044 * @description
1045 *
1046 * $translateProvider allows developers to register translation-tables, asynchronous loaders
1047 * and similar to configure translation behavior directly inside of a module.
1048 *
1049 */
1050/**
1051 * @ngdoc object
1052 * @name pascalprecht.translate.$translateDefaultInterpolation
1053 * @requires $interpolate
1054 *
1055 * @description
1056 * Uses angular's `$interpolate` services to interpolate strings against some values.
1057 *
1058 * Be aware to configure a proper sanitization strategy.
1059 *
1060 * See also:
1061 * * {@link pascalprecht.translate.$translateSanitization}
1062 *
1063 * @return {object} $translateDefaultInterpolation Interpolator service
1064 */
1065return a.$inject=["$translate"],c.$inject=["$STORAGE_KEY","$windowProvider","$translateSanitizationProvider","pascalprechtTranslateOverrider"],d.$inject=["$interpolate","$translateSanitization"],e.$inject=["$translate","$q","$interpolate","$compile","$parse","$rootScope"],g.$inject=["$translate","$rootScope"],j.$inject=["$parse","$translate"],k.$inject=["$cacheFactory"],angular.module("pascalprecht.translate",["ng"]).run(a),a.displayName="runTranslate",angular.module("pascalprecht.translate").provider("$translateSanitization",b),angular.module("pascalprecht.translate").constant("pascalprechtTranslateOverrider",{}).provider("$translate",c),c.displayName="displayName",angular.module("pascalprecht.translate").factory("$translateDefaultInterpolation",d),d.displayName="$translateDefaultInterpolation",angular.module("pascalprecht.translate").constant("$STORAGE_KEY","NG_TRANSLATE_LANG_KEY"),angular.module("pascalprecht.translate").directive("translate",e),e.displayName="translateDirective",angular.module("pascalprecht.translate").directive("translateCloak",g),g.displayName="translateCloakDirective",angular.module("pascalprecht.translate").directive("translateNamespace",h),h.displayName="translateNamespaceDirective",angular.module("pascalprecht.translate").directive("translateLanguage",i),i.displayName="translateLanguageDirective",angular.module("pascalprecht.translate").filter("translate",j),j.displayName="translateFilterFactory",angular.module("pascalprecht.translate").factory("$translationCache",k),k.displayName="$translationCache","pascalprecht.translate"});

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.