} An array of parameter names. Must be treated as read-only. If the\r\n * pattern has no parameters, an empty array is returned.\r\n */\r\nUrlMatcher.prototype.parameters = function (param) {\r\n if (!isDefined(param)) return this.$$paramNames;\r\n return this.params[param] || null;\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:UrlMatcher#validate\r\n * @methodOf ui.router.util.type:UrlMatcher\r\n *\r\n * @description\r\n * Checks an object hash of parameters to validate their correctness according to the parameter\r\n * types of this `UrlMatcher`.\r\n *\r\n * @param {Object} params The object hash of parameters to validate.\r\n * @returns {boolean} Returns `true` if `params` validates, otherwise `false`.\r\n */\r\nUrlMatcher.prototype.validates = function (params) {\r\n return this.params.$$validates(params);\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:UrlMatcher#format\r\n * @methodOf ui.router.util.type:UrlMatcher\r\n *\r\n * @description\r\n * Creates a URL that matches this pattern by substituting the specified values\r\n * for the path and search parameters. Null values for path parameters are\r\n * treated as empty strings.\r\n *\r\n * @example\r\n * \r\n * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' });\r\n * // returns '/user/bob?q=yes'\r\n * \r\n *\r\n * @param {Object} values the values to substitute for the parameters in this pattern.\r\n * @returns {string} the formatted URL (path and optionally search part).\r\n */\r\nUrlMatcher.prototype.format = function (values) {\r\n values = values || {};\r\n var segments = this.segments, params = this.parameters(), paramset = this.params;\r\n if (!this.validates(values)) return null;\r\n\r\n var i, search = false, nPath = segments.length - 1, nTotal = params.length, result = segments[0];\r\n\r\n function encodeDashes(str) { // Replace dashes with encoded \"\\-\"\r\n return encodeURIComponent(str).replace(/-/g, function(c) { return '%5C%' + c.charCodeAt(0).toString(16).toUpperCase(); });\r\n }\r\n\r\n for (i = 0; i < nTotal; i++) {\r\n var isPathParam = i < nPath;\r\n var name = params[i], param = paramset[name], value = param.value(values[name]);\r\n var isDefaultValue = param.isOptional && param.type.equals(param.value(), value);\r\n var squash = isDefaultValue ? param.squash : false;\r\n var encoded = param.type.encode(value);\r\n\r\n if (isPathParam) {\r\n var nextSegment = segments[i + 1];\r\n if (squash === false) {\r\n if (encoded != null) {\r\n if (isArray(encoded)) {\r\n result += map(encoded, encodeDashes).join(\"-\");\r\n } else {\r\n result += encodeURIComponent(encoded);\r\n }\r\n }\r\n result += nextSegment;\r\n } else if (squash === true) {\r\n var capture = result.match(/\\/$/) ? /\\/?(.*)/ : /(.*)/;\r\n result += nextSegment.match(capture)[1];\r\n } else if (isString(squash)) {\r\n result += squash + nextSegment;\r\n }\r\n } else {\r\n if (encoded == null || (isDefaultValue && squash !== false)) continue;\r\n if (!isArray(encoded)) encoded = [ encoded ];\r\n encoded = map(encoded, encodeURIComponent).join('&' + name + '=');\r\n result += (search ? '&' : '?') + (name + '=' + encoded);\r\n search = true;\r\n }\r\n }\r\n\r\n return result;\r\n};\r\n\r\n/**\r\n * @ngdoc object\r\n * @name ui.router.util.type:Type\r\n *\r\n * @description\r\n * Implements an interface to define custom parameter types that can be decoded from and encoded to\r\n * string parameters matched in a URL. Used by {@link ui.router.util.type:UrlMatcher `UrlMatcher`}\r\n * objects when matching or formatting URLs, or comparing or validating parameter values.\r\n *\r\n * See {@link ui.router.util.$urlMatcherFactory#methods_type `$urlMatcherFactory#type()`} for more\r\n * information on registering custom types.\r\n *\r\n * @param {Object} config A configuration object which contains the custom type definition. The object's\r\n * properties will override the default methods and/or pattern in `Type`'s public interface.\r\n * @example\r\n * \r\n * {\r\n * decode: function(val) { return parseInt(val, 10); },\r\n * encode: function(val) { return val && val.toString(); },\r\n * equals: function(a, b) { return this.is(a) && a === b; },\r\n * is: function(val) { return angular.isNumber(val) isFinite(val) && val % 1 === 0; },\r\n * pattern: /\\d+/\r\n * }\r\n * \r\n *\r\n * @property {RegExp} pattern The regular expression pattern used to match values of this type when\r\n * coming from a substring of a URL.\r\n *\r\n * @returns {Object} Returns a new `Type` object.\r\n */\r\nfunction Type(config) {\r\n extend(this, config);\r\n}\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:Type#is\r\n * @methodOf ui.router.util.type:Type\r\n *\r\n * @description\r\n * Detects whether a value is of a particular type. Accepts a native (decoded) value\r\n * and determines whether it matches the current `Type` object.\r\n *\r\n * @param {*} val The value to check.\r\n * @param {string} key Optional. If the type check is happening in the context of a specific\r\n * {@link ui.router.util.type:UrlMatcher `UrlMatcher`} object, this is the name of the\r\n * parameter in which `val` is stored. Can be used for meta-programming of `Type` objects.\r\n * @returns {Boolean} Returns `true` if the value matches the type, otherwise `false`.\r\n */\r\nType.prototype.is = function(val, key) {\r\n return true;\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:Type#encode\r\n * @methodOf ui.router.util.type:Type\r\n *\r\n * @description\r\n * Encodes a custom/native type value to a string that can be embedded in a URL. Note that the\r\n * return value does *not* need to be URL-safe (i.e. passed through `encodeURIComponent()`), it\r\n * only needs to be a representation of `val` that has been coerced to a string.\r\n *\r\n * @param {*} val The value to encode.\r\n * @param {string} key The name of the parameter in which `val` is stored. Can be used for\r\n * meta-programming of `Type` objects.\r\n * @returns {string} Returns a string representation of `val` that can be encoded in a URL.\r\n */\r\nType.prototype.encode = function(val, key) {\r\n return val;\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:Type#decode\r\n * @methodOf ui.router.util.type:Type\r\n *\r\n * @description\r\n * Converts a parameter value (from URL string or transition param) to a custom/native value.\r\n *\r\n * @param {string} val The URL parameter value to decode.\r\n * @param {string} key The name of the parameter in which `val` is stored. Can be used for\r\n * meta-programming of `Type` objects.\r\n * @returns {*} Returns a custom representation of the URL parameter value.\r\n */\r\nType.prototype.decode = function(val, key) {\r\n return val;\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @name ui.router.util.type:Type#equals\r\n * @methodOf ui.router.util.type:Type\r\n *\r\n * @description\r\n * Determines whether two decoded values are equivalent.\r\n *\r\n * @param {*} a A value to compare against.\r\n * @param {*} b A value to compare against.\r\n * @returns {Boolean} Returns `true` if the values are equivalent/equal, otherwise `false`.\r\n */\r\nType.prototype.equals = function(a, b) {\r\n return a == b;\r\n};\r\n\r\nType.prototype.$subPattern = function() {\r\n var sub = this.pattern.toString();\r\n return sub.substr(1, sub.length - 2);\r\n};\r\n\r\nType.prototype.pattern = /.*/;\r\n\r\nType.prototype.toString = function() { return \"{Type:\" + this.name + \"}\"; };\r\n\r\n/*\r\n * Wraps an existing custom Type as an array of Type, depending on 'mode'.\r\n * e.g.:\r\n * - urlmatcher pattern \"/path?{queryParam[]:int}\"\r\n * - url: \"/path?queryParam=1&queryParam=2\r\n * - $stateParams.queryParam will be [1, 2]\r\n * if `mode` is \"auto\", then\r\n * - url: \"/path?queryParam=1 will create $stateParams.queryParam: 1\r\n * - url: \"/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]\r\n */\r\nType.prototype.$asArray = function(mode, isSearch) {\r\n if (!mode) return this;\r\n if (mode === \"auto\" && !isSearch) throw new Error(\"'auto' array mode is for query parameters only\");\r\n return new ArrayType(this, mode);\r\n\r\n function ArrayType(type, mode) {\r\n function bindTo(type, callbackName) {\r\n return function() {\r\n return type[callbackName].apply(type, arguments);\r\n };\r\n }\r\n\r\n // Wrap non-array value as array\r\n function arrayWrap(val) { return isArray(val) ? val : (isDefined(val) ? [ val ] : []); }\r\n // Unwrap array value for \"auto\" mode. Return undefined for empty array.\r\n function arrayUnwrap(val) {\r\n switch(val.length) {\r\n case 0: return undefined;\r\n case 1: return mode === \"auto\" ? val[0] : val;\r\n default: return val;\r\n }\r\n }\r\n function falsey(val) { return !val; }\r\n\r\n // Wraps type (.is/.encode/.decode) functions to operate on each value of an array\r\n function arrayHandler(callback, allTruthyMode) {\r\n return function handleArray(val) {\r\n val = arrayWrap(val);\r\n var result = map(val, callback);\r\n if (allTruthyMode === true)\r\n return filter(result, falsey).length === 0;\r\n return arrayUnwrap(result);\r\n };\r\n }\r\n\r\n // Wraps type (.equals) functions to operate on each value of an array\r\n function arrayEqualsHandler(callback) {\r\n return function handleArray(val1, val2) {\r\n var left = arrayWrap(val1), right = arrayWrap(val2);\r\n if (left.length !== right.length) return false;\r\n for (var i = 0; i < left.length; i++) {\r\n if (!callback(left[i], right[i])) return false;\r\n }\r\n return true;\r\n };\r\n }\r\n\r\n this.encode = arrayHandler(bindTo(type, 'encode'));\r\n this.decode = arrayHandler(bindTo(type, 'decode'));\r\n this.is = arrayHandler(bindTo(type, 'is'), true);\r\n this.equals = arrayEqualsHandler(bindTo(type, 'equals'));\r\n this.pattern = type.pattern;\r\n this.$arrayMode = mode;\r\n }\r\n};\r\n\r\n\r\n\r\n/**\r\n * @ngdoc object\r\n * @name ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Factory for {@link ui.router.util.type:UrlMatcher `UrlMatcher`} instances. The factory\r\n * is also available to providers under the name `$urlMatcherFactoryProvider`.\r\n */\r\nfunction $UrlMatcherFactory() {\r\n $$UMFP = this;\r\n\r\n var isCaseInsensitive = false, isStrictMode = true, defaultSquashPolicy = false;\r\n\r\n function valToString(val) { return val != null ? val.toString().replace(/\\//g, \"%2F\") : val; }\r\n function valFromString(val) { return val != null ? val.toString().replace(/%2F/g, \"/\") : val; }\r\n// TODO: in 1.0, make string .is() return false if value is undefined by default.\r\n// function regexpMatches(val) { /*jshint validthis:true */ return isDefined(val) && this.pattern.test(val); }\r\n function regexpMatches(val) { /*jshint validthis:true */ return this.pattern.test(val); }\r\n\r\n var $types = {}, enqueue = true, typeQueue = [], injector, defaultTypes = {\r\n string: {\r\n encode: valToString,\r\n decode: valFromString,\r\n is: regexpMatches,\r\n pattern: /[^/]*/\r\n },\r\n int: {\r\n encode: valToString,\r\n decode: function(val) { return parseInt(val, 10); },\r\n is: function(val) { return isDefined(val) && this.decode(val.toString()) === val; },\r\n pattern: /\\d+/\r\n },\r\n bool: {\r\n encode: function(val) { return val ? 1 : 0; },\r\n decode: function(val) { return parseInt(val, 10) !== 0; },\r\n is: function(val) { return val === true || val === false; },\r\n pattern: /0|1/\r\n },\r\n date: {\r\n encode: function (val) {\r\n if (!this.is(val))\r\n return undefined;\r\n return [ val.getFullYear(),\r\n ('0' + (val.getMonth() + 1)).slice(-2),\r\n ('0' + val.getDate()).slice(-2)\r\n ].join(\"-\");\r\n },\r\n decode: function (val) {\r\n if (this.is(val)) return val;\r\n var match = this.capture.exec(val);\r\n return match ? new Date(match[1], match[2] - 1, match[3]) : undefined;\r\n },\r\n is: function(val) { return val instanceof Date && !isNaN(val.valueOf()); },\r\n equals: function (a, b) { return this.is(a) && this.is(b) && a.toISOString() === b.toISOString(); },\r\n pattern: /[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,\r\n capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/\r\n },\r\n json: {\r\n encode: angular.toJson,\r\n decode: angular.fromJson,\r\n is: angular.isObject,\r\n equals: angular.equals,\r\n pattern: /[^/]*/\r\n },\r\n any: { // does not encode/decode\r\n encode: angular.identity,\r\n decode: angular.identity,\r\n is: angular.identity,\r\n equals: angular.equals,\r\n pattern: /.*/\r\n }\r\n };\r\n\r\n function getDefaultConfig() {\r\n return {\r\n strict: isStrictMode,\r\n caseInsensitive: isCaseInsensitive\r\n };\r\n }\r\n\r\n function isInjectable(value) {\r\n return (isFunction(value) || (isArray(value) && isFunction(value[value.length - 1])));\r\n }\r\n\r\n /**\r\n * [Internal] Get the default value of a parameter, which may be an injectable function.\r\n */\r\n $UrlMatcherFactory.$$getDefaultValue = function(config) {\r\n if (!isInjectable(config.value)) return config.value;\r\n if (!injector) throw new Error(\"Injectable functions cannot be called at configuration time\");\r\n return injector.invoke(config.value);\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#caseInsensitive\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Defines whether URL matching should be case sensitive (the default behavior), or not.\r\n *\r\n * @param {boolean} value `false` to match URL in a case sensitive manner; otherwise `true`;\r\n * @returns {boolean} the current value of caseInsensitive\r\n */\r\n this.caseInsensitive = function(value) {\r\n if (isDefined(value))\r\n isCaseInsensitive = value;\r\n return isCaseInsensitive;\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#strictMode\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Defines whether URLs should match trailing slashes, or not (the default behavior).\r\n *\r\n * @param {boolean=} value `false` to match trailing slashes in URLs, otherwise `true`.\r\n * @returns {boolean} the current value of strictMode\r\n */\r\n this.strictMode = function(value) {\r\n if (isDefined(value))\r\n isStrictMode = value;\r\n return isStrictMode;\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#defaultSquashPolicy\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Sets the default behavior when generating or matching URLs with default parameter values.\r\n *\r\n * @param {string} value A string that defines the default parameter URL squashing behavior.\r\n * `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL\r\n * `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the\r\n * parameter is surrounded by slashes, squash (remove) one slash from the URL\r\n * any other string, e.g. \"~\": When generating an href with a default parameter value, squash (remove)\r\n * the parameter value from the URL and replace it with this string.\r\n */\r\n this.defaultSquashPolicy = function(value) {\r\n if (!isDefined(value)) return defaultSquashPolicy;\r\n if (value !== true && value !== false && !isString(value))\r\n throw new Error(\"Invalid squash policy: \" + value + \". Valid policies: false, true, arbitrary-string\");\r\n defaultSquashPolicy = value;\r\n return value;\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#compile\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Creates a {@link ui.router.util.type:UrlMatcher `UrlMatcher`} for the specified pattern.\r\n *\r\n * @param {string} pattern The URL pattern.\r\n * @param {Object} config The config object hash.\r\n * @returns {UrlMatcher} The UrlMatcher.\r\n */\r\n this.compile = function (pattern, config) {\r\n return new UrlMatcher(pattern, extend(getDefaultConfig(), config));\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#isMatcher\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Returns true if the specified object is a `UrlMatcher`, or false otherwise.\r\n *\r\n * @param {Object} object The object to perform the type check against.\r\n * @returns {Boolean} Returns `true` if the object matches the `UrlMatcher` interface, by\r\n * implementing all the same methods.\r\n */\r\n this.isMatcher = function (o) {\r\n if (!isObject(o)) return false;\r\n var result = true;\r\n\r\n forEach(UrlMatcher.prototype, function(val, name) {\r\n if (isFunction(val)) {\r\n result = result && (isDefined(o[name]) && isFunction(o[name]));\r\n }\r\n });\r\n return result;\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.util.$urlMatcherFactory#type\r\n * @methodOf ui.router.util.$urlMatcherFactory\r\n *\r\n * @description\r\n * Registers a custom {@link ui.router.util.type:Type `Type`} object that can be used to\r\n * generate URLs with typed parameters.\r\n *\r\n * @param {string} name The type name.\r\n * @param {Object|Function} definition The type definition. See\r\n * {@link ui.router.util.type:Type `Type`} for information on the values accepted.\r\n * @param {Object|Function} definitionFn (optional) A function that is injected before the app\r\n * runtime starts. The result of this function is merged into the existing `definition`.\r\n * See {@link ui.router.util.type:Type `Type`} for information on the values accepted.\r\n *\r\n * @returns {Object} Returns `$urlMatcherFactoryProvider`.\r\n *\r\n * @example\r\n * This is a simple example of a custom type that encodes and decodes items from an\r\n * array, using the array index as the URL-encoded value:\r\n *\r\n * \r\n * var list = ['John', 'Paul', 'George', 'Ringo'];\r\n *\r\n * $urlMatcherFactoryProvider.type('listItem', {\r\n * encode: function(item) {\r\n * // Represent the list item in the URL using its corresponding index\r\n * return list.indexOf(item);\r\n * },\r\n * decode: function(item) {\r\n * // Look up the list item by index\r\n * return list[parseInt(item, 10)];\r\n * },\r\n * is: function(item) {\r\n * // Ensure the item is valid by checking to see that it appears\r\n * // in the list\r\n * return list.indexOf(item) > -1;\r\n * }\r\n * });\r\n *\r\n * $stateProvider.state('list', {\r\n * url: \"/list/{item:listItem}\",\r\n * controller: function($scope, $stateParams) {\r\n * console.log($stateParams.item);\r\n * }\r\n * });\r\n *\r\n * // ...\r\n *\r\n * // Changes URL to '/list/3', logs \"Ringo\" to the console\r\n * $state.go('list', { item: \"Ringo\" });\r\n * \r\n *\r\n * This is a more complex example of a type that relies on dependency injection to\r\n * interact with services, and uses the parameter name from the URL to infer how to\r\n * handle encoding and decoding parameter values:\r\n *\r\n * \r\n * // Defines a custom type that gets a value from a service,\r\n * // where each service gets different types of values from\r\n * // a backend API:\r\n * $urlMatcherFactoryProvider.type('dbObject', {}, function(Users, Posts) {\r\n *\r\n * // Matches up services to URL parameter names\r\n * var services = {\r\n * user: Users,\r\n * post: Posts\r\n * };\r\n *\r\n * return {\r\n * encode: function(object) {\r\n * // Represent the object in the URL using its unique ID\r\n * return object.id;\r\n * },\r\n * decode: function(value, key) {\r\n * // Look up the object by ID, using the parameter\r\n * // name (key) to call the correct service\r\n * return services[key].findById(value);\r\n * },\r\n * is: function(object, key) {\r\n * // Check that object is a valid dbObject\r\n * return angular.isObject(object) && object.id && services[key];\r\n * }\r\n * equals: function(a, b) {\r\n * // Check the equality of decoded objects by comparing\r\n * // their unique IDs\r\n * return a.id === b.id;\r\n * }\r\n * };\r\n * });\r\n *\r\n * // In a config() block, you can then attach URLs with\r\n * // type-annotated parameters:\r\n * $stateProvider.state('users', {\r\n * url: \"/users\",\r\n * // ...\r\n * }).state('users.item', {\r\n * url: \"/{user:dbObject}\",\r\n * controller: function($scope, $stateParams) {\r\n * // $stateParams.user will now be an object returned from\r\n * // the Users service\r\n * },\r\n * // ...\r\n * });\r\n * \r\n */\r\n this.type = function (name, definition, definitionFn) {\r\n if (!isDefined(definition)) return $types[name];\r\n if ($types.hasOwnProperty(name)) throw new Error(\"A type named '\" + name + \"' has already been defined.\");\r\n\r\n $types[name] = new Type(extend({ name: name }, definition));\r\n if (definitionFn) {\r\n typeQueue.push({ name: name, def: definitionFn });\r\n if (!enqueue) flushTypeQueue();\r\n }\r\n return this;\r\n };\r\n\r\n // `flushTypeQueue()` waits until `$urlMatcherFactory` is injected before invoking the queued `definitionFn`s\r\n function flushTypeQueue() {\r\n while(typeQueue.length) {\r\n var type = typeQueue.shift();\r\n if (type.pattern) throw new Error(\"You cannot override a type's .pattern at runtime.\");\r\n angular.extend($types[type.name], injector.invoke(type.def));\r\n }\r\n }\r\n\r\n // Register default types. Store them in the prototype of $types.\r\n forEach(defaultTypes, function(type, name) { $types[name] = new Type(extend({name: name}, type)); });\r\n $types = inherit($types, {});\r\n\r\n /* No need to document $get, since it returns this */\r\n this.$get = ['$injector', function ($injector) {\r\n injector = $injector;\r\n enqueue = false;\r\n flushTypeQueue();\r\n\r\n forEach(defaultTypes, function(type, name) {\r\n if (!$types[name]) $types[name] = new Type(type);\r\n });\r\n return this;\r\n }];\r\n\r\n this.Param = function Param(id, type, config, location) {\r\n var self = this;\r\n config = unwrapShorthand(config);\r\n type = getType(config, type, location);\r\n var arrayMode = getArrayMode();\r\n type = arrayMode ? type.$asArray(arrayMode, location === \"search\") : type;\r\n if (type.name === \"string\" && !arrayMode && location === \"path\" && config.value === undefined)\r\n config.value = \"\"; // for 0.2.x; in 0.3.0+ do not automatically default to \"\"\r\n var isOptional = config.value !== undefined;\r\n var squash = getSquashPolicy(config, isOptional);\r\n var replace = getReplace(config, arrayMode, isOptional, squash);\r\n\r\n function unwrapShorthand(config) {\r\n var keys = isObject(config) ? objectKeys(config) : [];\r\n var isShorthand = indexOf(keys, \"value\") === -1 && indexOf(keys, \"type\") === -1 &&\r\n indexOf(keys, \"squash\") === -1 && indexOf(keys, \"array\") === -1;\r\n if (isShorthand) config = { value: config };\r\n config.$$fn = isInjectable(config.value) ? config.value : function () { return config.value; };\r\n return config;\r\n }\r\n\r\n function getType(config, urlType, location) {\r\n if (config.type && urlType) throw new Error(\"Param '\"+id+\"' has two type configurations.\");\r\n if (urlType) return urlType;\r\n if (!config.type) return (location === \"config\" ? $types.any : $types.string);\r\n return config.type instanceof Type ? config.type : new Type(config.type);\r\n }\r\n\r\n // array config: param name (param[]) overrides default settings. explicit config overrides param name.\r\n function getArrayMode() {\r\n var arrayDefaults = { array: (location === \"search\" ? \"auto\" : false) };\r\n var arrayParamNomenclature = id.match(/\\[\\]$/) ? { array: true } : {};\r\n return extend(arrayDefaults, arrayParamNomenclature, config).array;\r\n }\r\n\r\n /**\r\n * returns false, true, or the squash value to indicate the \"default parameter url squash policy\".\r\n */\r\n function getSquashPolicy(config, isOptional) {\r\n var squash = config.squash;\r\n if (!isOptional || squash === false) return false;\r\n if (!isDefined(squash) || squash == null) return defaultSquashPolicy;\r\n if (squash === true || isString(squash)) return squash;\r\n throw new Error(\"Invalid squash policy: '\" + squash + \"'. Valid policies: false, true, or arbitrary string\");\r\n }\r\n\r\n function getReplace(config, arrayMode, isOptional, squash) {\r\n var replace, configuredKeys, defaultPolicy = [\r\n { from: \"\", to: (isOptional || arrayMode ? undefined : \"\") },\r\n { from: null, to: (isOptional || arrayMode ? undefined : \"\") }\r\n ];\r\n replace = isArray(config.replace) ? config.replace : [];\r\n if (isString(squash))\r\n replace.push({ from: squash, to: undefined });\r\n configuredKeys = map(replace, function(item) { return item.from; } );\r\n return filter(defaultPolicy, function(item) { return indexOf(configuredKeys, item.from) === -1; }).concat(replace);\r\n }\r\n\r\n /**\r\n * [Internal] Get the default value of a parameter, which may be an injectable function.\r\n */\r\n function $$getDefaultValue() {\r\n if (!injector) throw new Error(\"Injectable functions cannot be called at configuration time\");\r\n return injector.invoke(config.$$fn);\r\n }\r\n\r\n /**\r\n * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the\r\n * default value, which may be the result of an injectable function.\r\n */\r\n function $value(value) {\r\n function hasReplaceVal(val) { return function(obj) { return obj.from === val; }; }\r\n function $replace(value) {\r\n var replacement = map(filter(self.replace, hasReplaceVal(value)), function(obj) { return obj.to; });\r\n return replacement.length ? replacement[0] : value;\r\n }\r\n value = $replace(value);\r\n return isDefined(value) ? self.type.decode(value) : $$getDefaultValue();\r\n }\r\n\r\n function toString() { return \"{Param:\" + id + \" \" + type + \" squash: '\" + squash + \"' optional: \" + isOptional + \"}\"; }\r\n\r\n extend(this, {\r\n id: id,\r\n type: type,\r\n location: location,\r\n array: arrayMode,\r\n squash: squash,\r\n replace: replace,\r\n isOptional: isOptional,\r\n value: $value,\r\n dynamic: undefined,\r\n config: config,\r\n toString: toString\r\n });\r\n };\r\n\r\n function ParamSet(params) {\r\n extend(this, params || {});\r\n }\r\n\r\n ParamSet.prototype = {\r\n $$new: function() {\r\n return inherit(this, extend(new ParamSet(), { $$parent: this}));\r\n },\r\n $$keys: function () {\r\n var keys = [], chain = [], parent = this,\r\n ignore = objectKeys(ParamSet.prototype);\r\n while (parent) { chain.push(parent); parent = parent.$$parent; }\r\n chain.reverse();\r\n forEach(chain, function(paramset) {\r\n forEach(objectKeys(paramset), function(key) {\r\n if (indexOf(keys, key) === -1 && indexOf(ignore, key) === -1) keys.push(key);\r\n });\r\n });\r\n return keys;\r\n },\r\n $$values: function(paramValues) {\r\n var values = {}, self = this;\r\n forEach(self.$$keys(), function(key) {\r\n values[key] = self[key].value(paramValues && paramValues[key]);\r\n });\r\n return values;\r\n },\r\n $$equals: function(paramValues1, paramValues2) {\r\n var equal = true, self = this;\r\n forEach(self.$$keys(), function(key) {\r\n var left = paramValues1 && paramValues1[key], right = paramValues2 && paramValues2[key];\r\n if (!self[key].type.equals(left, right)) equal = false;\r\n });\r\n return equal;\r\n },\r\n $$validates: function $$validate(paramValues) {\r\n var result = true, isOptional, val, param, self = this;\r\n\r\n forEach(this.$$keys(), function(key) {\r\n param = self[key];\r\n val = paramValues[key];\r\n isOptional = !val && param.isOptional;\r\n result = result && (isOptional || !!param.type.is(val));\r\n });\r\n return result;\r\n },\r\n $$parent: undefined\r\n };\r\n\r\n this.ParamSet = ParamSet;\r\n}\r\n\r\n// Register as a provider so it's available to other providers\r\nangular.module('ui.router.util').provider('$urlMatcherFactory', $UrlMatcherFactory);\r\nangular.module('ui.router.util').run(['$urlMatcherFactory', function($urlMatcherFactory) { }]);\r\n\r\n/**\r\n * @ngdoc object\r\n * @name ui.router.router.$urlRouterProvider\r\n *\r\n * @requires ui.router.util.$urlMatcherFactoryProvider\r\n * @requires $locationProvider\r\n *\r\n * @description\r\n * `$urlRouterProvider` has the responsibility of watching `$location`. \r\n * When `$location` changes it runs through a list of rules one by one until a \r\n * match is found. `$urlRouterProvider` is used behind the scenes anytime you specify \r\n * a url in a state configuration. All urls are compiled into a UrlMatcher object.\r\n *\r\n * There are several methods on `$urlRouterProvider` that make it useful to use directly\r\n * in your module config.\r\n */\r\n$UrlRouterProvider.$inject = ['$locationProvider', '$urlMatcherFactoryProvider'];\r\nfunction $UrlRouterProvider( $locationProvider, $urlMatcherFactory) {\r\n var rules = [], otherwise = null, interceptDeferred = false, listener;\r\n\r\n // Returns a string that is a prefix of all strings matching the RegExp\r\n function regExpPrefix(re) {\r\n var prefix = /^\\^((?:\\\\[^a-zA-Z0-9]|[^\\\\\\[\\]\\^$*+?.()|{}]+)*)/.exec(re.source);\r\n return (prefix != null) ? prefix[1].replace(/\\\\(.)/g, \"$1\") : '';\r\n }\r\n\r\n // Interpolates matched values into a String.replace()-style pattern\r\n function interpolate(pattern, match) {\r\n return pattern.replace(/\\$(\\$|\\d{1,2})/, function (m, what) {\r\n return match[what === '$' ? 0 : Number(what)];\r\n });\r\n }\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.router.$urlRouterProvider#rule\r\n * @methodOf ui.router.router.$urlRouterProvider\r\n *\r\n * @description\r\n * Defines rules that are used by `$urlRouterProvider` to find matches for\r\n * specific URLs.\r\n *\r\n * @example\r\n * \r\n * var app = angular.module('app', ['ui.router.router']);\r\n *\r\n * app.config(function ($urlRouterProvider) {\r\n * // Here's an example of how you might allow case insensitive urls\r\n * $urlRouterProvider.rule(function ($injector, $location) {\r\n * var path = $location.path(),\r\n * normalized = path.toLowerCase();\r\n *\r\n * if (path !== normalized) {\r\n * return normalized;\r\n * }\r\n * });\r\n * });\r\n * \r\n *\r\n * @param {object} rule Handler function that takes `$injector` and `$location`\r\n * services as arguments. You can use them to return a valid path as a string.\r\n *\r\n * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance\r\n */\r\n this.rule = function (rule) {\r\n if (!isFunction(rule)) throw new Error(\"'rule' must be a function\");\r\n rules.push(rule);\r\n return this;\r\n };\r\n\r\n /**\r\n * @ngdoc object\r\n * @name ui.router.router.$urlRouterProvider#otherwise\r\n * @methodOf ui.router.router.$urlRouterProvider\r\n *\r\n * @description\r\n * Defines a path that is used when an invalid route is requested.\r\n *\r\n * @example\r\n * \r\n * var app = angular.module('app', ['ui.router.router']);\r\n *\r\n * app.config(function ($urlRouterProvider) {\r\n * // if the path doesn't match any of the urls you configured\r\n * // otherwise will take care of routing the user to the\r\n * // specified url\r\n * $urlRouterProvider.otherwise('/index');\r\n *\r\n * // Example of using function rule as param\r\n * $urlRouterProvider.otherwise(function ($injector, $location) {\r\n * return '/a/valid/url';\r\n * });\r\n * });\r\n * \r\n *\r\n * @param {string|object} rule The url path you want to redirect to or a function \r\n * rule that returns the url path. The function version is passed two params: \r\n * `$injector` and `$location` services, and must return a url string.\r\n *\r\n * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance\r\n */\r\n this.otherwise = function (rule) {\r\n if (isString(rule)) {\r\n var redirect = rule;\r\n rule = function () { return redirect; };\r\n }\r\n else if (!isFunction(rule)) throw new Error(\"'rule' must be a function\");\r\n otherwise = rule;\r\n return this;\r\n };\r\n\r\n\r\n function handleIfMatch($injector, handler, match) {\r\n if (!match) return false;\r\n var result = $injector.invoke(handler, handler, { $match: match });\r\n return isDefined(result) ? result : true;\r\n }\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.router.$urlRouterProvider#when\r\n * @methodOf ui.router.router.$urlRouterProvider\r\n *\r\n * @description\r\n * Registers a handler for a given url matching. if handle is a string, it is\r\n * treated as a redirect, and is interpolated according to the syntax of match\r\n * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise).\r\n *\r\n * If the handler is a function, it is injectable. It gets invoked if `$location`\r\n * matches. You have the option of inject the match object as `$match`.\r\n *\r\n * The handler can return\r\n *\r\n * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter`\r\n * will continue trying to find another one that matches.\r\n * - **string** which is treated as a redirect and passed to `$location.url()`\r\n * - **void** or any **truthy** value tells `$urlRouter` that the url was handled.\r\n *\r\n * @example\r\n * \r\n * var app = angular.module('app', ['ui.router.router']);\r\n *\r\n * app.config(function ($urlRouterProvider) {\r\n * $urlRouterProvider.when($state.url, function ($match, $stateParams) {\r\n * if ($state.$current.navigable !== state ||\r\n * !equalForKeys($match, $stateParams) {\r\n * $state.transitionTo(state, $match, false);\r\n * }\r\n * });\r\n * });\r\n * \r\n *\r\n * @param {string|object} what The incoming path that you want to redirect.\r\n * @param {string|object} handler The path you want to redirect your user to.\r\n */\r\n this.when = function (what, handler) {\r\n var redirect, handlerIsString = isString(handler);\r\n if (isString(what)) what = $urlMatcherFactory.compile(what);\r\n\r\n if (!handlerIsString && !isFunction(handler) && !isArray(handler))\r\n throw new Error(\"invalid 'handler' in when()\");\r\n\r\n var strategies = {\r\n matcher: function (what, handler) {\r\n if (handlerIsString) {\r\n redirect = $urlMatcherFactory.compile(handler);\r\n handler = ['$match', function ($match) { return redirect.format($match); }];\r\n }\r\n return extend(function ($injector, $location) {\r\n return handleIfMatch($injector, handler, what.exec($location.path(), $location.search()));\r\n }, {\r\n prefix: isString(what.prefix) ? what.prefix : ''\r\n });\r\n },\r\n regex: function (what, handler) {\r\n if (what.global || what.sticky) throw new Error(\"when() RegExp must not be global or sticky\");\r\n\r\n if (handlerIsString) {\r\n redirect = handler;\r\n handler = ['$match', function ($match) { return interpolate(redirect, $match); }];\r\n }\r\n return extend(function ($injector, $location) {\r\n return handleIfMatch($injector, handler, what.exec($location.path()));\r\n }, {\r\n prefix: regExpPrefix(what)\r\n });\r\n }\r\n };\r\n\r\n var check = { matcher: $urlMatcherFactory.isMatcher(what), regex: what instanceof RegExp };\r\n\r\n for (var n in check) {\r\n if (check[n]) return this.rule(strategies[n](what, handler));\r\n }\r\n\r\n throw new Error(\"invalid 'what' in when()\");\r\n };\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.router.$urlRouterProvider#deferIntercept\r\n * @methodOf ui.router.router.$urlRouterProvider\r\n *\r\n * @description\r\n * Disables (or enables) deferring location change interception.\r\n *\r\n * If you wish to customize the behavior of syncing the URL (for example, if you wish to\r\n * defer a transition but maintain the current URL), call this method at configuration time.\r\n * Then, at run time, call `$urlRouter.listen()` after you have configured your own\r\n * `$locationChangeSuccess` event handler.\r\n *\r\n * @example\r\n * \r\n * var app = angular.module('app', ['ui.router.router']);\r\n *\r\n * app.config(function ($urlRouterProvider) {\r\n *\r\n * // Prevent $urlRouter from automatically intercepting URL changes;\r\n * // this allows you to configure custom behavior in between\r\n * // location changes and route synchronization:\r\n * $urlRouterProvider.deferIntercept();\r\n *\r\n * }).run(function ($rootScope, $urlRouter, UserService) {\r\n *\r\n * $rootScope.$on('$locationChangeSuccess', function(e) {\r\n * // UserService is an example service for managing user state\r\n * if (UserService.isLoggedIn()) return;\r\n *\r\n * // Prevent $urlRouter's default handler from firing\r\n * e.preventDefault();\r\n *\r\n * UserService.handleLogin().then(function() {\r\n * // Once the user has logged in, sync the current URL\r\n * // to the router:\r\n * $urlRouter.sync();\r\n * });\r\n * });\r\n *\r\n * // Configures $urlRouter's listener *after* your custom listener\r\n * $urlRouter.listen();\r\n * });\r\n * \r\n *\r\n * @param {boolean} defer Indicates whether to defer location change interception. Passing\r\n no parameter is equivalent to `true`.\r\n */\r\n this.deferIntercept = function (defer) {\r\n if (defer === undefined) defer = true;\r\n interceptDeferred = defer;\r\n };\r\n\r\n /**\r\n * @ngdoc object\r\n * @name ui.router.router.$urlRouter\r\n *\r\n * @requires $location\r\n * @requires $rootScope\r\n * @requires $injector\r\n * @requires $browser\r\n *\r\n * @description\r\n *\r\n */\r\n this.$get = $get;\r\n $get.$inject = ['$location', '$rootScope', '$injector', '$browser'];\r\n function $get( $location, $rootScope, $injector, $browser) {\r\n\r\n var baseHref = $browser.baseHref(), location = $location.url(), lastPushedUrl;\r\n\r\n function appendBasePath(url, isHtml5, absolute) {\r\n if (baseHref === '/') return url;\r\n if (isHtml5) return baseHref.slice(0, -1) + url;\r\n if (absolute) return baseHref.slice(1) + url;\r\n return url;\r\n }\r\n\r\n // TODO: Optimize groups of rules with non-empty prefix into some sort of decision tree\r\n function update(evt) {\r\n if (evt && evt.defaultPrevented) return;\r\n var ignoreUpdate = lastPushedUrl && $location.url() === lastPushedUrl;\r\n lastPushedUrl = undefined;\r\n if (ignoreUpdate) return true;\r\n\r\n function check(rule) {\r\n var handled = rule($injector, $location);\r\n\r\n if (!handled) return false;\r\n if (isString(handled)) $location.replace().url(handled);\r\n return true;\r\n }\r\n var n = rules.length, i;\r\n\r\n for (i = 0; i < n; i++) {\r\n if (check(rules[i])) return;\r\n }\r\n // always check otherwise last to allow dynamic updates to the set of rules\r\n if (otherwise) check(otherwise);\r\n }\r\n\r\n function listen() {\r\n listener = listener || $rootScope.$on('$locationChangeSuccess', update);\r\n return listener;\r\n }\r\n\r\n if (!interceptDeferred) listen();\r\n\r\n return {\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.router.$urlRouter#sync\r\n * @methodOf ui.router.router.$urlRouter\r\n *\r\n * @description\r\n * Triggers an update; the same update that happens when the address bar url changes, aka `$locationChangeSuccess`.\r\n * This method is useful when you need to use `preventDefault()` on the `$locationChangeSuccess` event,\r\n * perform some custom logic (route protection, auth, config, redirection, etc) and then finally proceed\r\n * with the transition by calling `$urlRouter.sync()`.\r\n *\r\n * @example\r\n * \r\n * angular.module('app', ['ui.router'])\r\n * .run(function($rootScope, $urlRouter) {\r\n * $rootScope.$on('$locationChangeSuccess', function(evt) {\r\n * // Halt state change from even starting\r\n * evt.preventDefault();\r\n * // Perform custom logic\r\n * var meetsRequirement = ...\r\n * // Continue with the update and state transition if logic allows\r\n * if (meetsRequirement) $urlRouter.sync();\r\n * });\r\n * });\r\n * \r\n */\r\n sync: function() {\r\n update();\r\n },\r\n\r\n listen: function() {\r\n return listen();\r\n },\r\n\r\n update: function(read) {\r\n if (read) {\r\n location = $location.url();\r\n return;\r\n }\r\n if ($location.url() === location) return;\r\n\r\n $location.url(location);\r\n $location.replace();\r\n },\r\n\r\n push: function(urlMatcher, params, options) {\r\n $location.url(urlMatcher.format(params || {}));\r\n lastPushedUrl = options && options.$$avoidResync ? $location.url() : undefined;\r\n if (options && options.replace) $location.replace();\r\n },\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.router.$urlRouter#href\r\n * @methodOf ui.router.router.$urlRouter\r\n *\r\n * @description\r\n * A URL generation method that returns the compiled URL for a given\r\n * {@link ui.router.util.type:UrlMatcher `UrlMatcher`}, populated with the provided parameters.\r\n *\r\n * @example\r\n * \r\n * $bob = $urlRouter.href(new UrlMatcher(\"/about/:person\"), {\r\n * person: \"bob\"\r\n * });\r\n * // $bob == \"/about/bob\";\r\n * \r\n *\r\n * @param {UrlMatcher} urlMatcher The `UrlMatcher` object which is used as the template of the URL to generate.\r\n * @param {object=} params An object of parameter values to fill the matcher's required parameters.\r\n * @param {object=} options Options object. The options are:\r\n *\r\n * - **`absolute`** - {boolean=false}, If true will generate an absolute url, e.g. \"http://www.example.com/fullurl\".\r\n *\r\n * @returns {string} Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`\r\n */\r\n href: function(urlMatcher, params, options) {\r\n if (!urlMatcher.validates(params)) return null;\r\n\r\n var isHtml5 = $locationProvider.html5Mode();\r\n if (angular.isObject(isHtml5)) {\r\n isHtml5 = isHtml5.enabled;\r\n }\r\n \r\n var url = urlMatcher.format(params);\r\n options = options || {};\r\n\r\n if (!isHtml5 && url !== null) {\r\n url = \"#\" + $locationProvider.hashPrefix() + url;\r\n }\r\n url = appendBasePath(url, isHtml5, options.absolute);\r\n\r\n if (!options.absolute || !url) {\r\n return url;\r\n }\r\n\r\n var slash = (!isHtml5 && url ? '/' : ''), port = $location.port();\r\n port = (port === 80 || port === 443 ? '' : ':' + port);\r\n\r\n return [$location.protocol(), '://', $location.host(), port, slash, url].join('');\r\n }\r\n };\r\n }\r\n}\r\n\r\nangular.module('ui.router.router').provider('$urlRouter', $UrlRouterProvider);\r\n\r\n/**\r\n * @ngdoc object\r\n * @name ui.router.state.$stateProvider\r\n *\r\n * @requires ui.router.router.$urlRouterProvider\r\n * @requires ui.router.util.$urlMatcherFactoryProvider\r\n *\r\n * @description\r\n * The new `$stateProvider` works similar to Angular's v1 router, but it focuses purely\r\n * on state.\r\n *\r\n * A state corresponds to a \"place\" in the application in terms of the overall UI and\r\n * navigation. A state describes (via the controller / template / view properties) what\r\n * the UI looks like and does at that place.\r\n *\r\n * States often have things in common, and the primary way of factoring out these\r\n * commonalities in this model is via the state hierarchy, i.e. parent/child states aka\r\n * nested states.\r\n *\r\n * The `$stateProvider` provides interfaces to declare these states for your app.\r\n */\r\n$StateProvider.$inject = ['$urlRouterProvider', '$urlMatcherFactoryProvider'];\r\nfunction $StateProvider( $urlRouterProvider, $urlMatcherFactory) {\r\n\r\n var root, states = {}, $state, queue = {}, abstractKey = 'abstract';\r\n\r\n // Builds state properties from definition passed to registerState()\r\n var stateBuilder = {\r\n\r\n // Derive parent state from a hierarchical name only if 'parent' is not explicitly defined.\r\n // state.children = [];\r\n // if (parent) parent.children.push(state);\r\n parent: function(state) {\r\n if (isDefined(state.parent) && state.parent) return findState(state.parent);\r\n // regex matches any valid composite state name\r\n // would match \"contact.list\" but not \"contacts\"\r\n var compositeName = /^(.+)\\.[^.]+$/.exec(state.name);\r\n return compositeName ? findState(compositeName[1]) : root;\r\n },\r\n\r\n // inherit 'data' from parent and override by own values (if any)\r\n data: function(state) {\r\n if (state.parent && state.parent.data) {\r\n state.data = state.self.data = extend({}, state.parent.data, state.data);\r\n }\r\n return state.data;\r\n },\r\n\r\n // Build a URLMatcher if necessary, either via a relative or absolute URL\r\n url: function(state) {\r\n var url = state.url, config = { params: state.params || {} };\r\n\r\n if (isString(url)) {\r\n if (url.charAt(0) == '^') return $urlMatcherFactory.compile(url.substring(1), config);\r\n return (state.parent.navigable || root).url.concat(url, config);\r\n }\r\n\r\n if (!url || $urlMatcherFactory.isMatcher(url)) return url;\r\n throw new Error(\"Invalid url '\" + url + \"' in state '\" + state + \"'\");\r\n },\r\n\r\n // Keep track of the closest ancestor state that has a URL (i.e. is navigable)\r\n navigable: function(state) {\r\n return state.url ? state : (state.parent ? state.parent.navigable : null);\r\n },\r\n\r\n // Own parameters for this state. state.url.params is already built at this point. Create and add non-url params\r\n ownParams: function(state) {\r\n var params = state.url && state.url.params || new $$UMFP.ParamSet();\r\n forEach(state.params || {}, function(config, id) {\r\n if (!params[id]) params[id] = new $$UMFP.Param(id, null, config, \"config\");\r\n });\r\n return params;\r\n },\r\n\r\n // Derive parameters for this state and ensure they're a super-set of parent's parameters\r\n params: function(state) {\r\n return state.parent && state.parent.params ? extend(state.parent.params.$$new(), state.ownParams) : new $$UMFP.ParamSet();\r\n },\r\n\r\n // If there is no explicit multi-view configuration, make one up so we don't have\r\n // to handle both cases in the view directive later. Note that having an explicit\r\n // 'views' property will mean the default unnamed view properties are ignored. This\r\n // is also a good time to resolve view names to absolute names, so everything is a\r\n // straight lookup at link time.\r\n views: function(state) {\r\n var views = {};\r\n\r\n forEach(isDefined(state.views) ? state.views : { '': state }, function (view, name) {\r\n if (name.indexOf('@') < 0) name += '@' + state.parent.name;\r\n views[name] = view;\r\n });\r\n return views;\r\n },\r\n\r\n // Keep a full path from the root down to this state as this is needed for state activation.\r\n path: function(state) {\r\n return state.parent ? state.parent.path.concat(state) : []; // exclude root from path\r\n },\r\n\r\n // Speed up $state.contains() as it's used a lot\r\n includes: function(state) {\r\n var includes = state.parent ? extend({}, state.parent.includes) : {};\r\n includes[state.name] = true;\r\n return includes;\r\n },\r\n\r\n $delegates: {}\r\n };\r\n\r\n function isRelative(stateName) {\r\n return stateName.indexOf(\".\") === 0 || stateName.indexOf(\"^\") === 0;\r\n }\r\n\r\n function findState(stateOrName, base) {\r\n if (!stateOrName) return undefined;\r\n\r\n var isStr = isString(stateOrName),\r\n name = isStr ? stateOrName : stateOrName.name,\r\n path = isRelative(name);\r\n\r\n if (path) {\r\n if (!base) throw new Error(\"No reference point given for path '\" + name + \"'\");\r\n base = findState(base);\r\n \r\n var rel = name.split(\".\"), i = 0, pathLength = rel.length, current = base;\r\n\r\n for (; i < pathLength; i++) {\r\n if (rel[i] === \"\" && i === 0) {\r\n current = base;\r\n continue;\r\n }\r\n if (rel[i] === \"^\") {\r\n if (!current.parent) throw new Error(\"Path '\" + name + \"' not valid for state '\" + base.name + \"'\");\r\n current = current.parent;\r\n continue;\r\n }\r\n break;\r\n }\r\n rel = rel.slice(i).join(\".\");\r\n name = current.name + (current.name && rel ? \".\" : \"\") + rel;\r\n }\r\n var state = states[name];\r\n\r\n if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) {\r\n return state;\r\n }\r\n return undefined;\r\n }\r\n\r\n function queueState(parentName, state) {\r\n if (!queue[parentName]) {\r\n queue[parentName] = [];\r\n }\r\n queue[parentName].push(state);\r\n }\r\n\r\n function flushQueuedChildren(parentName) {\r\n var queued = queue[parentName] || [];\r\n while(queued.length) {\r\n registerState(queued.shift());\r\n }\r\n }\r\n\r\n function registerState(state) {\r\n // Wrap a new object around the state so we can store our private details easily.\r\n state = inherit(state, {\r\n self: state,\r\n resolve: state.resolve || {},\r\n toString: function() { return this.name; }\r\n });\r\n\r\n var name = state.name;\r\n if (!isString(name) || name.indexOf('@') >= 0) throw new Error(\"State must have a valid name\");\r\n if (states.hasOwnProperty(name)) throw new Error(\"State '\" + name + \"'' is already defined\");\r\n\r\n // Get parent name\r\n var parentName = (name.indexOf('.') !== -1) ? name.substring(0, name.lastIndexOf('.'))\r\n : (isString(state.parent)) ? state.parent\r\n : (isObject(state.parent) && isString(state.parent.name)) ? state.parent.name\r\n : '';\r\n\r\n // If parent is not registered yet, add state to queue and register later\r\n if (parentName && !states[parentName]) {\r\n return queueState(parentName, state.self);\r\n }\r\n\r\n for (var key in stateBuilder) {\r\n if (isFunction(stateBuilder[key])) state[key] = stateBuilder[key](state, stateBuilder.$delegates[key]);\r\n }\r\n states[name] = state;\r\n\r\n // Register the state in the global state list and with $urlRouter if necessary.\r\n if (!state[abstractKey] && state.url) {\r\n $urlRouterProvider.when(state.url, ['$match', '$stateParams', function ($match, $stateParams) {\r\n if ($state.$current.navigable != state || !equalForKeys($match, $stateParams)) {\r\n $state.transitionTo(state, $match, { inherit: true, location: false });\r\n }\r\n }]);\r\n }\r\n\r\n // Register any queued children\r\n flushQueuedChildren(name);\r\n\r\n return state;\r\n }\r\n\r\n // Checks text to see if it looks like a glob.\r\n function isGlob (text) {\r\n return text.indexOf('*') > -1;\r\n }\r\n\r\n // Returns true if glob matches current $state name.\r\n function doesStateMatchGlob (glob) {\r\n var globSegments = glob.split('.'),\r\n segments = $state.$current.name.split('.');\r\n\r\n //match greedy starts\r\n if (globSegments[0] === '**') {\r\n segments = segments.slice(indexOf(segments, globSegments[1]));\r\n segments.unshift('**');\r\n }\r\n //match greedy ends\r\n if (globSegments[globSegments.length - 1] === '**') {\r\n segments.splice(indexOf(segments, globSegments[globSegments.length - 2]) + 1, Number.MAX_VALUE);\r\n segments.push('**');\r\n }\r\n\r\n if (globSegments.length != segments.length) {\r\n return false;\r\n }\r\n\r\n //match single stars\r\n for (var i = 0, l = globSegments.length; i < l; i++) {\r\n if (globSegments[i] === '*') {\r\n segments[i] = '*';\r\n }\r\n }\r\n\r\n return segments.join('') === globSegments.join('');\r\n }\r\n\r\n\r\n // Implicit root state that is always active\r\n root = registerState({\r\n name: '',\r\n url: '^',\r\n views: null,\r\n 'abstract': true\r\n });\r\n root.navigable = null;\r\n\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.state.$stateProvider#decorator\r\n * @methodOf ui.router.state.$stateProvider\r\n *\r\n * @description\r\n * Allows you to extend (carefully) or override (at your own peril) the \r\n * `stateBuilder` object used internally by `$stateProvider`. This can be used \r\n * to add custom functionality to ui-router, for example inferring templateUrl \r\n * based on the state name.\r\n *\r\n * When passing only a name, it returns the current (original or decorated) builder\r\n * function that matches `name`.\r\n *\r\n * The builder functions that can be decorated are listed below. Though not all\r\n * necessarily have a good use case for decoration, that is up to you to decide.\r\n *\r\n * In addition, users can attach custom decorators, which will generate new \r\n * properties within the state's internal definition. There is currently no clear \r\n * use-case for this beyond accessing internal states (i.e. $state.$current), \r\n * however, expect this to become increasingly relevant as we introduce additional \r\n * meta-programming features.\r\n *\r\n * **Warning**: Decorators should not be interdependent because the order of \r\n * execution of the builder functions in non-deterministic. Builder functions \r\n * should only be dependent on the state definition object and super function.\r\n *\r\n *\r\n * Existing builder functions and current return values:\r\n *\r\n * - **parent** `{object}` - returns the parent state object.\r\n * - **data** `{object}` - returns state data, including any inherited data that is not\r\n * overridden by own values (if any).\r\n * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}\r\n * or `null`.\r\n * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is \r\n * navigable).\r\n * - **params** `{object}` - returns an array of state params that are ensured to \r\n * be a super-set of parent's params.\r\n * - **views** `{object}` - returns a views object where each key is an absolute view \r\n * name (i.e. \"viewName@stateName\") and each value is the config object \r\n * (template, controller) for the view. Even when you don't use the views object \r\n * explicitly on a state config, one is still created for you internally.\r\n * So by decorating this builder function you have access to decorating template \r\n * and controller properties.\r\n * - **ownParams** `{object}` - returns an array of params that belong to the state, \r\n * not including any params defined by ancestor states.\r\n * - **path** `{string}` - returns the full path from the root down to this state. \r\n * Needed for state activation.\r\n * - **includes** `{object}` - returns an object that includes every state that \r\n * would pass a `$state.includes()` test.\r\n *\r\n * @example\r\n * \r\n * // Override the internal 'views' builder with a function that takes the state\r\n * // definition, and a reference to the internal function being overridden:\r\n * $stateProvider.decorator('views', function (state, parent) {\r\n * var result = {},\r\n * views = parent(state);\r\n *\r\n * angular.forEach(views, function (config, name) {\r\n * var autoName = (state.name + '.' + name).replace('.', '/');\r\n * config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';\r\n * result[name] = config;\r\n * });\r\n * return result;\r\n * });\r\n *\r\n * $stateProvider.state('home', {\r\n * views: {\r\n * 'contact.list': { controller: 'ListController' },\r\n * 'contact.item': { controller: 'ItemController' }\r\n * }\r\n * });\r\n *\r\n * // ...\r\n *\r\n * $state.go('home');\r\n * // Auto-populates list and item views with /partials/home/contact/list.html,\r\n * // and /partials/home/contact/item.html, respectively.\r\n * \r\n *\r\n * @param {string} name The name of the builder function to decorate. \r\n * @param {object} func A function that is responsible for decorating the original \r\n * builder function. The function receives two parameters:\r\n *\r\n * - `{object}` - state - The state config object.\r\n * - `{object}` - super - The original builder function.\r\n *\r\n * @return {object} $stateProvider - $stateProvider instance\r\n */\r\n this.decorator = decorator;\r\n function decorator(name, func) {\r\n /*jshint validthis: true */\r\n if (isString(name) && !isDefined(func)) {\r\n return stateBuilder[name];\r\n }\r\n if (!isFunction(func) || !isString(name)) {\r\n return this;\r\n }\r\n if (stateBuilder[name] && !stateBuilder.$delegates[name]) {\r\n stateBuilder.$delegates[name] = stateBuilder[name];\r\n }\r\n stateBuilder[name] = func;\r\n return this;\r\n }\r\n\r\n /**\r\n * @ngdoc function\r\n * @name ui.router.state.$stateProvider#state\r\n * @methodOf ui.router.state.$stateProvider\r\n *\r\n * @description\r\n * Registers a state configuration under a given state name. The stateConfig object\r\n * has the following acceptable properties.\r\n *\r\n * @param {string} name A unique state name, e.g. \"home\", \"about\", \"contacts\".\r\n * To create a parent/child state use a dot, e.g. \"about.sales\", \"home.newest\".\r\n * @param {object} stateConfig State configuration object.\r\n * @param {string|function=} stateConfig.template\r\n * \r\n * html template as a string or a function that returns\r\n * an html template as a string which should be used by the uiView directives. This property \r\n * takes precedence over templateUrl.\r\n * \r\n * If `template` is a function, it will be called with the following parameters:\r\n *\r\n * - {array.<object>} - state parameters extracted from the current $location.path() by\r\n * applying the current state\r\n *\r\n * template:\r\n * \"inline template definition
\" +\r\n * \"\"
\r\n * template: function(params) {\r\n * return \"generated template
\"; }\r\n *