/**

* @license AngularJS v1.2.12

* (c) 2010-2014 Google, Inc. http://angularjs.org

* License: MIT

*/

(function(window, document, undefined) {'use strict';

/**

* @description

*

* This object provides a utility for producing rich Error messages within

* Angular. It can be called as follows:

*

* var exampleMinErr = minErr('example');

* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);

*

* The above creates an instance of minErr in the example namespace. The

* resulting error will have a namespaced error code of example.one. The

* resulting error will replace {0} with the value of foo, and {1} with the

* value of bar. The object is not restricted in the number of arguments it can

* take.

*

* If fewer arguments are specified than necessary for interpolation, the extra

* interpolation markers will be preserved in the final string.

*

* Since data will be parsed statically during a build step, some restrictions

* are applied with respect to how minErr instances are created and called.

* Instances should have names of the form namespaceMinErr for a minErr created

* using minErr('namespace') . Error codes, namespaces and template strings

* should all be static strings, not variables or general expressions.

*

* @param {string} module The namespace to use for the new minErr instance.

* @returns {function(string, string, ...): Error} instance

*/

function minErr(module) {

}

/* We need to tell jshint what variables are being exported */

/* global

-angular,

-msie,

-jqLite,

-jQuery,

-slice,

-push,

-toString,

-ngMinErr,

-_angular,

-angularModule,

-nodeName_,

-uid,

-lowercase,

-uppercase,

-manualLowercase,

-manualUppercase,

-nodeName_,

-isArrayLike,

-forEach,

-sortedKeys,

-forEachSorted,

-reverseParams,

-nextUid,

-setHashKey,

-extend,

-int,

-inherit,

-noop,

-identity,

-valueFn,

-isUndefined,

-isDefined,

-isObject,

-isString,

-isNumber,

-isDate,

-isArray,

-isFunction,

-isRegExp,

-isWindow,

-isScope,

-isFile,

-isBoolean,

-trim,

-isElement,

-makeMap,

-map,

-size,

-includes,

-indexOf,

-arrayRemove,

-isLeafNode,

-copy,

-shallowCopy,

-equals,

-csp,

-concat,

-sliceArgs,

-bind,

-toJsonReplacer,

-toJson,

-fromJson,

-toBoolean,

-startingTag,

-tryDecodeURIComponent,

-parseKeyValue,

-toKeyValue,

-encodeUriSegment,

-encodeUriQuery,

-angularInit,

-bootstrap,

-snake_case,

-bindJQuery,

-assertArg,

-assertArgFn,

-assertNotHasOwnProperty,

-getter,

-getBlockElements,

*/

////////////////////////////////////

/**

* @ngdoc function

* @name angular.lowercase

* @function

*

* @description Converts the specified string to lowercase.

* @param {string} string String to be converted to lowercase.

* @returns {string} Lowercased string.

*/

var lowercase = function(string){return isString(string) ? string.toLowerCase() : string;};

/**

* @ngdoc function

* @name angular.uppercase

* @function

*

* @description Converts the specified string to uppercase.

* @param {string} string String to be converted to uppercase.

* @returns {string} Uppercased string.

*/

var uppercase = function(string){return isString(string) ? string.toUpperCase() : string;};

var manualLowercase = function(s) {

};

var manualUppercase = function(s) {

};

// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish

// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods

// with correct but slower alternatives.

if ('i' !== 'I'.toLowerCase()) {

lowercase = manualLowercase;

uppercase = manualUppercase;

}

var /** holds major version number for IE or NaN for real browsers */

msie,

jqLite, // delay binding since jQuery could be loaded after us.

jQuery, // delay binding

slice = [].slice,

push = [].push,

toString = Object.prototype.toString,

ngMinErr = minErr('ng'),

_angular = window.angular,

/** @name angular */

angular = window.angular || (window.angular = {}),

angularModule,

nodeName_,

uid = ['0', '0', '0'];

/**

* IE 11 changed the format of the UserAgent string.

* See http://msdn.microsoft.com/en-us/library/ms537503.aspx

*/

msie = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]);

if (isNaN(msie)) {

msie = int((/trident\/.*; rv:(\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]);

}

/**

* @private

* @param {*} obj

* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,

* String ...)

*/

function isArrayLike(obj) {

}

/**

* @ngdoc function

* @name angular.forEach

* @function

*

* @description

* Invokes the `iterator` function once for each item in `obj` collection, which can be either an

* object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`

* is the value of an object property or an array element and `key` is the object property key or

* array element index. Specifying a `context` for the function is optional.

*

* It is worth noting that `.forEach` does not iterate over inherited properties because it filters

* using the `hasOwnProperty` method.

*

<pre>

var values = {name: 'misko', gender: 'male'};

var log = [];

angular.forEach(values, function(value, key){

this.push(key + ': ' + value);

}, log);

expect(log).toEqual(['name: misko', 'gender: male']);

</pre>

*

* @param {Object|Array} obj Object to iterate over.

* @param {Function} iterator Iterator function.

* @param {Object=} context Object to become context (`this`) for the iterator function.

* @returns {Object|Array} Reference to `obj`.

*/

function forEach(obj, iterator, context) {

}

function sortedKeys(obj) {

}

function forEachSorted(obj, iterator, context) {

}

/**

* when using forEach the params are value, key, but it is often useful to have key, value.

* @param {function(string, *)} iteratorFn

* @returns {function(*, string)}

*/

function reverseParams(iteratorFn) {

return function(value, key) { iteratorFn(key, value); };

}

/**

* A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric

* characters such as '012ABC'. The reason why we are not using simply a number counter is that

* the number string gets longer over time, and it can also overflow, where as the nextId

* will grow much slower, it is a string, and it will never overflow.

*

* @returns an unique alpha-numeric string

*/

function nextUid() {

}

/**

* Set or clear the hashkey for an object.

* @param obj object

* @param h the hashkey (!truthy to delete the hashkey)

*/

function setHashKey(obj, h) {

}

/**

* @ngdoc function

* @name angular.extend

* @function

*

* @description

* Extends the destination object `dst` by copying all of the properties from the `src` object(s)

* to `dst`. You can specify multiple `src` objects.

*

* @param {Object} dst Destination object.

* @param {...Object} src Source object(s).

* @returns {Object} Reference to `dst`.

*/

function extend(dst) {

}

function int(str) {

return parseInt(str, 10);

}

function inherit(parent, extra) {

return extend(new (extend(function() {}, {prototype:parent}))(), extra);

}

/**

* @ngdoc function

* @name angular.noop

* @function

*

* @description

* A function that performs no operations. This function can be useful when writing code in the

* functional style.

<pre>

function foo(callback) {

var result = calculateResult();

(callback || angular.noop)(result);

}

</pre>

*/

function noop() {}

noop.$inject = [];

/**

* @ngdoc function

* @name angular.identity

* @function

*

* @description

* A function that returns its first argument. This function is useful when writing code in the

* functional style.

*

<pre>

function transformer(transformationFn, value) {

return (transformationFn || angular.identity)(value);

};

</pre>

*/

function identity($) {return $;}

identity.$inject = [];

function valueFn(value) {return function() {return value;};}

/**

* @ngdoc function

* @name angular.isUndefined

* @function

*

* @description

* Determines if a reference is undefined.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is undefined.

*/

function isUndefined(value){return typeof value === 'undefined';}

/**

* @ngdoc function

* @name angular.isDefined

* @function

*

* @description

* Determines if a reference is defined.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is defined.

*/

function isDefined(value){return typeof value !== 'undefined';}

/**

* @ngdoc function

* @name angular.isObject

* @function

*

* @description

* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not

* considered to be objects.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is an `Object` but not `null`.

*/

function isObject(value){return value != null && typeof value === 'object';}

/**

* @ngdoc function

* @name angular.isString

* @function

*

* @description

* Determines if a reference is a `String`.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a `String`.

*/

function isString(value){return typeof value === 'string';}

/**

* @ngdoc function

* @name angular.isNumber

* @function

*

* @description

* Determines if a reference is a `Number`.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a `Number`.

*/

function isNumber(value){return typeof value === 'number';}

/**

* @ngdoc function

* @name angular.isDate

* @function

*

* @description

* Determines if a value is a date.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a `Date`.

*/

function isDate(value){

return toString.call(value) === '[object Date]';

}

/**

* @ngdoc function

* @name angular.isArray

* @function

*

* @description

* Determines if a reference is an `Array`.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is an `Array`.

*/

function isArray(value) {

return toString.call(value) === '[object Array]';

}

/**

* @ngdoc function

* @name angular.isFunction

* @function

*

* @description

* Determines if a reference is a `Function`.

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a `Function`.

*/

function isFunction(value){return typeof value === 'function';}

/**

* Determines if a value is a regular expression object.

*

* @private

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a `RegExp`.

*/

function isRegExp(value) {

return toString.call(value) === '[object RegExp]';

}

/**

* Checks if `obj` is a window object.

*

* @private

* @param {*} obj Object to check

* @returns {boolean} True if `obj` is a window obj.

*/

function isWindow(obj) {

return obj && obj.document && obj.location && obj.alert && obj.setInterval;

}

function isScope(obj) {

return obj && obj.$evalAsync && obj.$watch;

}

function isFile(obj) {

return toString.call(obj) === '[object File]';

}

function isBoolean(value) {

return typeof value === 'boolean';

}

var trim = (function() {

// native trim is way faster: http://jsperf.com/angular-trim-test

// but IE doesn't have it... :-(

// TODO: we should move this into IE/ES5 polyfill

if (!String.prototype.trim) {

return function(value) {

return isString(value) ? value.replace(/^\s\s*/, '').replace(/\s\s*$/, '') : value;

};

}

return function(value) {

return isString(value) ? value.trim() : value;

};

})();

/**

* @ngdoc function

* @name angular.isElement

* @function

*

* @description

* Determines if a reference is a DOM element (or wrapped jQuery element).

*

* @param {*} value Reference to check.

* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).

*/

function isElement(node) {

}

/**

* @param str 'key1,key2,...'

* @returns {object} in the form of {key1:true, key2:true, ...}

*/

function makeMap(str){

}

if (msie < 9) {

nodeName_ = function(element) {

};

} else {

nodeName_ = function(element) {

return element.nodeName ? element.nodeName : element[0].nodeName;

};

}

function map(obj, iterator, context) {

}

/**

* @description

* Determines the number of elements in an array, the number of properties an object has, or

* the length of a string.

*

* Note: This function is used to augment the Object type in Angular expressions. See

* {@link angular.Object} for more information about Angular arrays.

*

* @param {Object|Array|string} obj Object, array, or string to inspect.

* @param {boolean} [ownPropsOnly=false] Count only "own" properties in an object

* @returns {number} The size of `obj` or `0` if `obj` is neither an object nor an array.

*/

function size(obj, ownPropsOnly) {

}

function includes(array, obj) {

return indexOf(array, obj) != -1;

}

function indexOf(array, obj) {

}

function arrayRemove(array, value) {

}

function isLeafNode (node) {

}

/**

* @ngdoc function

* @name angular.copy

* @function

*

* @description

* Creates a deep copy of `source`, which should be an object or an array.

*

* * If no destination is supplied, a copy of the object or array is created.

* * If a destination is provided, all of its elements (for array) or properties (for objects)

* are deleted and then all elements/properties from the source are copied to it.

* * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.

* * If `source` is identical to 'destination' an exception will be thrown.

*

* @param {*} source The source that will be used to make a copy.

* Can be any type, including primitives, `null`, and `undefined`.

* @param {(Object|Array)=} destination Destination into which the source is copied. If

* provided, must be of the same type as `source`.

* @returns {*} The copy or updated `destination`, if `destination` was specified.

*

* @example

<doc:example>

<doc:source>

<div ng-controller="Controller">

<form novalidate class="simple-form">

Name: <input type="text" ng-model="user.name" /><br />

E-mail: <input type="email" ng-model="user.email" /><br />

Gender: <input type="radio" ng-model="user.gender" value="male" />male

<input type="radio" ng-model="user.gender" value="female" />female<br />

<button ng-click="reset()">RESET</button>

<button ng-click="update(user)">SAVE</button>

</form>

<pre>form = {{user | json}}</pre>

<pre>master = {{master | json}}</pre>

</div>

<script>

function Controller($scope) {

$scope.master= {};

$scope.update = function(user) {

// Example with 1 argument

$scope.master= angular.copy(user);

};

$scope.reset = function() {

// Example with 2 arguments

angular.copy($scope.master, $scope.user);

};

$scope.reset();

}

</script>

</doc:source>

</doc:example>

*/

function copy(source, destination){

}

/**

* Create a shallow copy of an object

*/

function shallowCopy(src, dst) {

}

/**

* @ngdoc function

* @name angular.equals

* @function

*

* @description

* Determines if two objects or two values are equivalent. Supports value types, regular

* expressions, arrays and objects.

*

* Two objects or values are considered equivalent if at least one of the following is true:

*

* * Both objects or values pass `===` comparison.

* * Both objects or values are of the same type and all of their properties are equal by

* comparing them with `angular.equals`.

* * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)

* * Both values represent the same regular expression (In JavasScript,

* /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual

* representation matches).

*

* During a property comparison, properties of `function` type and properties with names

* that begin with `$` are ignored.

*

* Scope and DOMWindow objects are being compared only by identify (`===`).

*

* @param {*} o1 Object or value to compare.

* @param {*} o2 Object or value to compare.

* @returns {boolean} True if arguments are equal.

*/

function equals(o1, o2) {

}

function csp() {

}

function concat(array1, array2, index) {

return array1.concat(slice.call(array2, index));

}

function sliceArgs(args, startIndex) {

return slice.call(args, startIndex || 0);

}

/* jshint -W101 */

/**

* @ngdoc function

* @name angular.bind

* @function

*

* @description

* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for

* `fn`). You can supply optional `args` that are prebound to the function. This feature is also

* known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as

* distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).

*

* @param {Object} self Context which `fn` should be evaluated in.

* @param {function()} fn Function to be bound.

* @param {...*} args Optional arguments to be prebound to the `fn` function call.

* @returns {function()} Function that wraps the `fn` with all the specified bindings.

*/

/* jshint +W101 */

function bind(self, fn) {

}

function toJsonReplacer(key, value) {