diff options
Diffstat (limited to 'vendor/assets/components/angular-route')
9 files changed, 1396 insertions, 0 deletions
diff --git a/vendor/assets/components/angular-route/.bower.json b/vendor/assets/components/angular-route/.bower.json new file mode 100644 index 0000000..bb2f83a --- /dev/null +++ b/vendor/assets/components/angular-route/.bower.json @@ -0,0 +1,21 @@ +{ + "name": "angular-route", + "version": "1.6.1", + "license": "MIT", + "main": "./angular-route.js", + "ignore": [], + "dependencies": { + "angular": "1.6.1" + }, + "homepage": "https://github.com/angular/bower-angular-route", + "_release": "1.6.1", + "_resolution": { + "type": "version", + "tag": "v1.6.1", + "commit": "409c45cfc589d66457f7cbb11aa1fc47f8dbbf78" + }, + "_source": "https://github.com/angular/bower-angular-route.git", + "_target": "^1.6.1", + "_originalSource": "angular-route", + "_direct": true +}
\ No newline at end of file diff --git a/vendor/assets/components/angular-route/LICENSE.md b/vendor/assets/components/angular-route/LICENSE.md new file mode 100644 index 0000000..2c395ee --- /dev/null +++ b/vendor/assets/components/angular-route/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Angular + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/assets/components/angular-route/README.md b/vendor/assets/components/angular-route/README.md new file mode 100644 index 0000000..2cd4f90 --- /dev/null +++ b/vendor/assets/components/angular-route/README.md @@ -0,0 +1,68 @@ +# packaged angular-route + +This repo is for distribution on `npm` and `bower`. The source for this module is in the +[main AngularJS repo](https://github.com/angular/angular.js/tree/master/src/ngRoute). +Please file issues and pull requests against that repo. + +## Install + +You can install this package either with `npm` or with `bower`. + +### npm + +```shell +npm install angular-route +``` + +Then add `ngRoute` as a dependency for your app: + +```javascript +angular.module('myApp', [require('angular-route')]); +``` + +### bower + +```shell +bower install angular-route +``` + +Add a `<script>` to your `index.html`: + +```html +<script src="/bower_components/angular-route/angular-route.js"></script> +``` + +Then add `ngRoute` as a dependency for your app: + +```javascript +angular.module('myApp', ['ngRoute']); +``` + +## Documentation + +Documentation is available on the +[AngularJS docs site](http://docs.angularjs.org/api/ngRoute). + +## License + +The MIT License + +Copyright (c) 2010-2015 Google, Inc. http://angularjs.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/vendor/assets/components/angular-route/angular-route.js b/vendor/assets/components/angular-route/angular-route.js new file mode 100644 index 0000000..42e25ce --- /dev/null +++ b/vendor/assets/components/angular-route/angular-route.js @@ -0,0 +1,1216 @@ +/** + * @license AngularJS v1.6.1 + * (c) 2010-2016 Google, Inc. http://angularjs.org + * License: MIT + */ +(function(window, angular) {'use strict'; + +/* global shallowCopy: true */ + +/** + * Creates a shallow copy of an object, an array or a primitive. + * + * Assumes that there are no proto properties for objects. + */ +function shallowCopy(src, dst) { + if (isArray(src)) { + dst = dst || []; + + for (var i = 0, ii = src.length; i < ii; i++) { + dst[i] = src[i]; + } + } else if (isObject(src)) { + dst = dst || {}; + + for (var key in src) { + if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) { + dst[key] = src[key]; + } + } + } + + return dst || src; +} + +/* global shallowCopy: false */ + +// `isArray` and `isObject` are necessary for `shallowCopy()` (included via `src/shallowCopy.js`). +// They are initialized inside the `$RouteProvider`, to ensure `window.angular` is available. +var isArray; +var isObject; +var isDefined; + +/** + * @ngdoc module + * @name ngRoute + * @description + * + * # ngRoute + * + * The `ngRoute` module provides routing and deeplinking services and directives for angular apps. + * + * ## Example + * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`. + * + * + * <div doc-module-components="ngRoute"></div> + */ +/* global -ngRouteModule */ +var ngRouteModule = angular. + module('ngRoute', []). + provider('$route', $RouteProvider). + // Ensure `$route` will be instantiated in time to capture the initial `$locationChangeSuccess` + // event (unless explicitly disabled). This is necessary in case `ngView` is included in an + // asynchronously loaded template. + run(instantiateRoute); +var $routeMinErr = angular.$$minErr('ngRoute'); +var isEagerInstantiationEnabled; + + +/** + * @ngdoc provider + * @name $routeProvider + * @this + * + * @description + * + * Used for configuring routes. + * + * ## Example + * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`. + * + * ## Dependencies + * Requires the {@link ngRoute `ngRoute`} module to be installed. + */ +function $RouteProvider() { + isArray = angular.isArray; + isObject = angular.isObject; + isDefined = angular.isDefined; + + function inherit(parent, extra) { + return angular.extend(Object.create(parent), extra); + } + + var routes = {}; + + /** + * @ngdoc method + * @name $routeProvider#when + * + * @param {string} path Route path (matched against `$location.path`). If `$location.path` + * contains redundant trailing slash or is missing one, the route will still match and the + * `$location.path` will be updated to add or drop the trailing slash to exactly match the + * route definition. + * + * * `path` can contain named groups starting with a colon: e.g. `:name`. All characters up + * to the next slash are matched and stored in `$routeParams` under the given `name` + * when the route matches. + * * `path` can contain named groups starting with a colon and ending with a star: + * e.g.`:name*`. All characters are eagerly stored in `$routeParams` under the given `name` + * when the route matches. + * * `path` can contain optional named groups with a question mark: e.g.`:name?`. + * + * For example, routes like `/color/:color/largecode/:largecode*\/edit` will match + * `/color/brown/largecode/code/with/slashes/edit` and extract: + * + * * `color: brown` + * * `largecode: code/with/slashes`. + * + * + * @param {Object} route Mapping information to be assigned to `$route.current` on route + * match. + * + * Object properties: + * + * - `controller` – `{(string|Function)=}` – Controller fn that should be associated with + * newly created scope or the name of a {@link angular.Module#controller registered + * controller} if passed as a string. + * - `controllerAs` – `{string=}` – An identifier name for a reference to the controller. + * If present, the controller will be published to scope under the `controllerAs` name. + * - `template` – `{(string|Function)=}` – html template as a string or a function that + * returns an html template as a string which should be used by {@link + * ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives. + * This property takes precedence over `templateUrl`. + * + * If `template` is a function, it will be called with the following parameters: + * + * - `{Array.<Object>}` - route parameters extracted from the current + * `$location.path()` by applying the current route + * + * One of `template` or `templateUrl` is required. + * + * - `templateUrl` – `{(string|Function)=}` – path or function that returns a path to an html + * template that should be used by {@link ngRoute.directive:ngView ngView}. + * + * If `templateUrl` is a function, it will be called with the following parameters: + * + * - `{Array.<Object>}` - route parameters extracted from the current + * `$location.path()` by applying the current route + * + * One of `templateUrl` or `template` is required. + * + * - `resolve` - `{Object.<string, Function>=}` - An optional map of dependencies which should + * be injected into the controller. If any of these dependencies are promises, the router + * will wait for them all to be resolved or one to be rejected before the controller is + * instantiated. + * If all the promises are resolved successfully, the values of the resolved promises are + * injected and {@link ngRoute.$route#$routeChangeSuccess $routeChangeSuccess} event is + * fired. If any of the promises are rejected the + * {@link ngRoute.$route#$routeChangeError $routeChangeError} event is fired. + * For easier access to the resolved dependencies from the template, the `resolve` map will + * be available on the scope of the route, under `$resolve` (by default) or a custom name + * specified by the `resolveAs` property (see below). This can be particularly useful, when + * working with {@link angular.Module#component components} as route templates.<br /> + * <div class="alert alert-warning"> + * **Note:** If your scope already contains a property with this name, it will be hidden + * or overwritten. Make sure, you specify an appropriate name for this property, that + * does not collide with other properties on the scope. + * </div> + * The map object is: + * + * - `key` – `{string}`: a name of a dependency to be injected into the controller. + * - `factory` - `{string|Function}`: If `string` then it is an alias for a service. + * Otherwise if function, then it is {@link auto.$injector#invoke injected} + * and the return value is treated as the dependency. If the result is a promise, it is + * resolved before its value is injected into the controller. Be aware that + * `ngRoute.$routeParams` will still refer to the previous route within these resolve + * functions. Use `$route.current.params` to access the new route parameters, instead. + * + * - `resolveAs` - `{string=}` - The name under which the `resolve` map will be available on + * the scope of the route. If omitted, defaults to `$resolve`. + * + * - `redirectTo` – `{(string|Function)=}` – value to update + * {@link ng.$location $location} path with and trigger route redirection. + * + * If `redirectTo` is a function, it will be called with the following parameters: + * + * - `{Object.<string>}` - route parameters extracted from the current + * `$location.path()` by applying the current route templateUrl. + * - `{string}` - current `$location.path()` + * - `{Object}` - current `$location.search()` + * + * The custom `redirectTo` function is expected to return a string which will be used + * to update `$location.url()`. If the function throws an error, no further processing will + * take place and the {@link ngRoute.$route#$routeChangeError $routeChangeError} event will + * be fired. + * + * Routes that specify `redirectTo` will not have their controllers, template functions + * or resolves called, the `$location` will be changed to the redirect url and route + * processing will stop. The exception to this is if the `redirectTo` is a function that + * returns `undefined`. In this case the route transition occurs as though there was no + * redirection. + * + * - `resolveRedirectTo` – `{Function=}` – a function that will (eventually) return the value + * to update {@link ng.$location $location} URL with and trigger route redirection. In + * contrast to `redirectTo`, dependencies can be injected into `resolveRedirectTo` and the + * return value can be either a string or a promise that will be resolved to a string. + * + * Similar to `redirectTo`, if the return value is `undefined` (or a promise that gets + * resolved to `undefined`), no redirection takes place and the route transition occurs as + * though there was no redirection. + * + * If the function throws an error or the returned promise gets rejected, no further + * processing will take place and the + * {@link ngRoute.$route#$routeChangeError $routeChangeError} event will be fired. + * + * `redirectTo` takes precedence over `resolveRedirectTo`, so specifying both on the same + * route definition, will cause the latter to be ignored. + * + * - `[reloadOnSearch=true]` - `{boolean=}` - reload route when only `$location.search()` + * or `$location.hash()` changes. + * + * If the option is set to `false` and url in the browser changes, then + * `$routeUpdate` event is broadcasted on the root scope. + * + * - `[caseInsensitiveMatch=false]` - `{boolean=}` - match routes without being case sensitive + * + * If the option is set to `true`, then the particular route can be matched without being + * case sensitive + * + * @returns {Object} self + * + * @description + * Adds a new route definition to the `$route` service. + */ + this.when = function(path, route) { + //copy original route object to preserve params inherited from proto chain + var routeCopy = shallowCopy(route); + if (angular.isUndefined(routeCopy.reloadOnSearch)) { + routeCopy.reloadOnSearch = true; + } + if (angular.isUndefined(routeCopy.caseInsensitiveMatch)) { + routeCopy.caseInsensitiveMatch = this.caseInsensitiveMatch; + } + routes[path] = angular.extend( + routeCopy, + path && pathRegExp(path, routeCopy) + ); + + // create redirection for trailing slashes + if (path) { + var redirectPath = (path[path.length - 1] === '/') + ? path.substr(0, path.length - 1) + : path + '/'; + + routes[redirectPath] = angular.extend( + {redirectTo: path}, + pathRegExp(redirectPath, routeCopy) + ); + } + + return this; + }; + + /** + * @ngdoc property + * @name $routeProvider#caseInsensitiveMatch + * @description + * + * A boolean property indicating if routes defined + * using this provider should be matched using a case insensitive + * algorithm. Defaults to `false`. + */ + this.caseInsensitiveMatch = false; + + /** + * @param path {string} path + * @param opts {Object} options + * @return {?Object} + * + * @description + * Normalizes the given path, returning a regular expression + * and the original path. + * + * Inspired by pathRexp in visionmedia/express/lib/utils.js. + */ + function pathRegExp(path, opts) { + var insensitive = opts.caseInsensitiveMatch, + ret = { + originalPath: path, + regexp: path + }, + keys = ret.keys = []; + + path = path + .replace(/([().])/g, '\\$1') + .replace(/(\/)?:(\w+)(\*\?|[?*])?/g, function(_, slash, key, option) { + var optional = (option === '?' || option === '*?') ? '?' : null; + var star = (option === '*' || option === '*?') ? '*' : null; + keys.push({ name: key, optional: !!optional }); + slash = slash || ''; + return '' + + (optional ? '' : slash) + + '(?:' + + (optional ? slash : '') + + (star && '(.+?)' || '([^/]+)') + + (optional || '') + + ')' + + (optional || ''); + }) + .replace(/([/$*])/g, '\\$1'); + + ret.regexp = new RegExp('^' + path + '$', insensitive ? 'i' : ''); + return ret; + } + + /** + * @ngdoc method + * @name $routeProvider#otherwise + * + * @description + * Sets route definition that will be used on route change when no other route definition + * is matched. + * + * @param {Object|string} params Mapping information to be assigned to `$route.current`. + * If called with a string, the value maps to `redirectTo`. + * @returns {Object} self + */ + this.otherwise = function(params) { + if (typeof params === 'string') { + params = {redirectTo: params}; + } + this.when(null, params); + return this; + }; + + /** + * @ngdoc method + * @name $routeProvider#eagerInstantiationEnabled + * @kind function + * + * @description + * Call this method as a setter to enable/disable eager instantiation of the + * {@link ngRoute.$route $route} service upon application bootstrap. You can also call it as a + * getter (i.e. without any arguments) to get the current value of the + * `eagerInstantiationEnabled` flag. + * + * Instantiating `$route` early is necessary for capturing the initial + * {@link ng.$location#$locationChangeStart $locationChangeStart} event and navigating to the + * appropriate route. Usually, `$route` is instantiated in time by the + * {@link ngRoute.ngView ngView} directive. Yet, in cases where `ngView` is included in an + * asynchronously loaded template (e.g. in another directive's template), the directive factory + * might not be called soon enough for `$route` to be instantiated _before_ the initial + * `$locationChangeSuccess` event is fired. Eager instantiation ensures that `$route` is always + * instantiated in time, regardless of when `ngView` will be loaded. + * + * The default value is true. + * + * **Note**:<br /> + * You may want to disable the default behavior when unit-testing modules that depend on + * `ngRoute`, in order to avoid an unexpected request for the default route's template. + * + * @param {boolean=} enabled - If provided, update the internal `eagerInstantiationEnabled` flag. + * + * @returns {*} The current value of the `eagerInstantiationEnabled` flag if used as a getter or + * itself (for chaining) if used as a setter. + */ + isEagerInstantiationEnabled = true; + this.eagerInstantiationEnabled = function eagerInstantiationEnabled(enabled) { + if (isDefined(enabled)) { + isEagerInstantiationEnabled = enabled; + return this; + } + + return isEagerInstantiationEnabled; + }; + + + this.$get = ['$rootScope', + '$location', + '$routeParams', + '$q', + '$injector', + '$templateRequest', + '$sce', + function($rootScope, $location, $routeParams, $q, $injector, $templateRequest, $sce) { + + /** + * @ngdoc service + * @name $route + * @requires $location + * @requires $routeParams + * + * @property {Object} current Reference to the current route definition. + * The route definition contains: + * + * - `controller`: The controller constructor as defined in the route definition. + * - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for + * controller instantiation. The `locals` contain + * the resolved values of the `resolve` map. Additionally the `locals` also contain: + * + * - `$scope` - The current route scope. + * - `$template` - The current route template HTML. + * + * The `locals` will be assigned to the route scope's `$resolve` property. You can override + * the property name, using `resolveAs` in the route definition. See + * {@link ngRoute.$routeProvider $routeProvider} for more info. + * + * @property {Object} routes Object with all route configuration Objects as its properties. + * + * @description + * `$route` is used for deep-linking URLs to controllers and views (HTML partials). + * It watches `$location.url()` and tries to map the path to an existing route definition. + * + * Requires the {@link ngRoute `ngRoute`} module to be installed. + * + * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API. + * + * The `$route` service is typically used in conjunction with the + * {@link ngRoute.directive:ngView `ngView`} directive and the + * {@link ngRoute.$routeParams `$routeParams`} service. + * + * @example + * This example shows how changing the URL hash causes the `$route` to match a route against the + * URL, and the `ngView` pulls in the partial. + * + * <example name="$route-service" module="ngRouteExample" + * deps="angular-route.js" fixBase="true"> + * <file name="index.html"> + * <div ng-controller="MainController"> + * Choose: + * <a href="Book/Moby">Moby</a> | + * <a href="Book/Moby/ch/1">Moby: Ch1</a> | + * <a href="Book/Gatsby">Gatsby</a> | + * <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> | + * <a href="Book/Scarlet">Scarlet Letter</a><br/> + * + * <div ng-view></div> + * + * <hr /> + * + * <pre>$location.path() = {{$location.path()}}</pre> + * <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre> + * <pre>$route.current.params = {{$route.current.params}}</pre> + * <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre> + * <pre>$routeParams = {{$routeParams}}</pre> + * </div> + * </file> + * + * <file name="book.html"> + * controller: {{name}}<br /> + * Book Id: {{params.bookId}}<br /> + * </file> + * + * <file name="chapter.html"> + * controller: {{name}}<br /> + * Book Id: {{params.bookId}}<br /> + * Chapter Id: {{params.chapterId}} + * </file> + * + * <file name="script.js"> + * angular.module('ngRouteExample', ['ngRoute']) + * + * .controller('MainController', function($scope, $route, $routeParams, $location) { + * $scope.$route = $route; + * $scope.$location = $location; + * $scope.$routeParams = $routeParams; + * }) + * + * .controller('BookController', function($scope, $routeParams) { + * $scope.name = 'BookController'; + * $scope.params = $routeParams; + * }) + * + * .controller('ChapterController', function($scope, $routeParams) { + * $scope.name = 'ChapterController'; + * $scope.params = $routeParams; + * }) + * + * .config(function($routeProvider, $locationProvider) { + * $routeProvider + * .when('/Book/:bookId', { + * templateUrl: 'book.html', + * controller: 'BookController', + * resolve: { + * // I will cause a 1 second delay + * delay: function($q, $timeout) { + * var delay = $q.defer(); + * $timeout(delay.resolve, 1000); + * return delay.promise; + * } + * } + * }) + * .when('/Book/:bookId/ch/:chapterId', { + * templateUrl: 'chapter.html', + * controller: 'ChapterController' + * }); + * + * // configure html5 to get links working on jsfiddle + * $locationProvider.html5Mode(true); + * }); + * + * </file> + * + * <file name="protractor.js" type="protractor"> + * it('should load and compile correct template', function() { + * element(by.linkText('Moby: Ch1')).click(); + * var content = element(by.css('[ng-view]')).getText(); + * expect(content).toMatch(/controller: ChapterController/); + * expect(content).toMatch(/Book Id: Moby/); + * expect(content).toMatch(/Chapter Id: 1/); + * + * element(by.partialLinkText('Scarlet')).click(); + * + * content = element(by.css('[ng-view]')).getText(); + * expect(content).toMatch(/controller: BookController/); + * expect(content).toMatch(/Book Id: Scarlet/); + * }); + * </file> + * </example> + */ + + /** + * @ngdoc event + * @name $route#$routeChangeStart + * @eventType broadcast on root scope + * @description + * Broadcasted before a route change. At this point the route services starts + * resolving all of the dependencies needed for the route change to occur. + * Typically this involves fetching the view template as well as any dependencies + * defined in `resolve` route property. Once all of the dependencies are resolved + * `$routeChangeSuccess` is fired. + * + * The route change (and the `$location` change that triggered it) can be prevented + * by calling `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} + * for more details about event object. + * + * @param {Object} angularEvent Synthetic event object. + * @param {Route} next Future route information. + * @param {Route} current Current route information. + */ + + /** + * @ngdoc event + * @name $route#$routeChangeSuccess + * @eventType broadcast on root scope + * @description + * Broadcasted after a route change has happened successfully. + * The `resolve` dependencies are now available in the `current.locals` property. + * + * {@link ngRoute.directive:ngView ngView} listens for the directive + * to instantiate the controller and render the view. + * + * @param {Object} angularEvent Synthetic event object. + * @param {Route} current Current route information. + * @param {Route|Undefined} previous Previous route information, or undefined if current is + * first route entered. + */ + + /** + * @ngdoc event + * @name $route#$routeChangeError + * @eventType broadcast on root scope + * @description + * Broadcasted if a redirection function fails or any redirection or resolve promises are + * rejected. + * + * @param {Object} angularEvent Synthetic event object + * @param {Route} current Current route information. + * @param {Route} previous Previous route information. + * @param {Route} rejection The thrown error or the rejection reason of the promise. Usually + * the rejection reason is the error that caused the promise to get rejected. + */ + + /** + * @ngdoc event + * @name $route#$routeUpdate + * @eventType broadcast on root scope + * @description + * The `reloadOnSearch` property has been set to false, and we are reusing the same + * instance of the Controller. + * + * @param {Object} angularEvent Synthetic event object + * @param {Route} current Current/previous route information. + */ + + var forceReload = false, + preparedRoute, + preparedRouteIsUpdateOnly, + $route = { + routes: routes, + + /** + * @ngdoc method + * @name $route#reload + * + * @description + * Causes `$route` service to reload the current route even if + * {@link ng.$location $location} hasn't changed. + * + * As a result of that, {@link ngRoute.directive:ngView ngView} + * creates new scope and reinstantiates the controller. + */ + reload: function() { + forceReload = true; + + var fakeLocationEvent = { + defaultPrevented: false, + preventDefault: function fakePreventDefault() { + this.defaultPrevented = true; + forceReload = false; + } + }; + + $rootScope.$evalAsync(function() { + prepareRoute(fakeLocationEvent); + if (!fakeLocationEvent.defaultPrevented) commitRoute(); + }); + }, + + /** + * @ngdoc method + * @name $route#updateParams + * + * @description + * Causes `$route` service to update the current URL, replacing + * current route parameters with those specified in `newParams`. + * Provided property names that match the route's path segment + * definitions will be interpolated into the location's path, while + * remaining properties will be treated as query params. + * + * @param {!Object<string, string>} newParams mapping of URL parameter names to values + */ + updateParams: function(newParams) { + if (this.current && this.current.$$route) { + newParams = angular.extend({}, this.current.params, newParams); + $location.path(interpolate(this.current.$$route.originalPath, newParams)); + // interpolate modifies newParams, only query params are left + $location.search(newParams); + } else { + throw $routeMinErr('norout', 'Tried updating route when with no current route'); + } + } + }; + + $rootScope.$on('$locationChangeStart', prepareRoute); + $rootScope.$on('$locationChangeSuccess', commitRoute); + + return $route; + + ///////////////////////////////////////////////////// + + /** + * @param on {string} current url + * @param route {Object} route regexp to match the url against + * @return {?Object} + * + * @description + * Check if the route matches the current url. + * + * Inspired by match in + * visionmedia/express/lib/router/router.js. + */ + function switchRouteMatcher(on, route) { + var keys = route.keys, + params = {}; + + if (!route.regexp) return null; + + var m = route.regexp.exec(on); + if (!m) return null; + + for (var i = 1, len = m.length; i < len; ++i) { + var key = keys[i - 1]; + + var val = m[i]; + + if (key && val) { + params[key.name] = val; + } + } + return params; + } + + function prepareRoute($locationEvent) { + var lastRoute = $route.current; + + preparedRoute = parseRoute(); + preparedRouteIsUpdateOnly = preparedRoute && lastRoute && preparedRoute.$$route === lastRoute.$$route + && angular.equals(preparedRoute.pathParams, lastRoute.pathParams) + && !preparedRoute.reloadOnSearch && !forceReload; + + if (!preparedRouteIsUpdateOnly && (lastRoute || preparedRoute)) { + if ($rootScope.$broadcast('$routeChangeStart', preparedRoute, lastRoute).defaultPrevented) { + if ($locationEvent) { + $locationEvent.preventDefault(); + } + } + } + } + + function commitRoute() { + var lastRoute = $route.current; + var nextRoute = preparedRoute; + + if (preparedRouteIsUpdateOnly) { + lastRoute.params = nextRoute.params; + angular.copy(lastRoute.params, $routeParams); + $rootScope.$broadcast('$routeUpdate', lastRoute); + } else if (nextRoute || lastRoute) { + forceReload = false; + $route.current = nextRoute; + + var nextRoutePromise = $q.resolve(nextRoute); + + nextRoutePromise. + then(getRedirectionData). + then(handlePossibleRedirection). + then(function(keepProcessingRoute) { + return keepProcessingRoute && nextRoutePromise. + then(resolveLocals). + then(function(locals) { + // after route change + if (nextRoute === $route.current) { + if (nextRoute) { + nextRoute.locals = locals; + angular.copy(nextRoute.params, $routeParams); + } + $rootScope.$broadcast('$routeChangeSuccess', nextRoute, lastRoute); + } + }); + }).catch(function(error) { + if (nextRoute === $route.current) { + $rootScope.$broadcast('$routeChangeError', nextRoute, lastRoute, error); + } + }); + } + } + + function getRedirectionData(route) { + var data = { + route: route, + hasRedirection: false + }; + + if (route) { + if (route.redirectTo) { + if (angular.isString(route.redirectTo)) { + data.path = interpolate(route.redirectTo, route.params); + data.search = route.params; + data.hasRedirection = true; + } else { + var oldPath = $location.path(); + var oldSearch = $location.search(); + var newUrl = route.redirectTo(route.pathParams, oldPath, oldSearch); + + if (angular.isDefined(newUrl)) { + data.url = newUrl; + data.hasRedirection = true; + } + } + } else if (route.resolveRedirectTo) { + return $q. + resolve($injector.invoke(route.resolveRedirectTo)). + then(function(newUrl) { + if (angular.isDefined(newUrl)) { + data.url = newUrl; + data.hasRedirection = true; + } + + return data; + }); + } + } + + return data; + } + + function handlePossibleRedirection(data) { + var keepProcessingRoute = true; + + if (data.route !== $route.current) { + keepProcessingRoute = false; + } else if (data.hasRedirection) { + var oldUrl = $location.url(); + var newUrl = data.url; + + if (newUrl) { + $location. + url(newUrl). + replace(); + } else { + newUrl = $location. + path(data.path). + search(data.search). + replace(). + url(); + } + + if (newUrl !== oldUrl) { + // Exit out and don't process current next value, + // wait for next location change from redirect + keepProcessingRoute = false; + } + } + + return keepProcessingRoute; + } + + function resolveLocals(route) { + if (route) { + var locals = angular.extend({}, route.resolve); + angular.forEach(locals, function(value, key) { + locals[key] = angular.isString(value) ? + $injector.get(value) : + $injector.invoke(value, null, null, key); + }); + var template = getTemplateFor(route); + if (angular.isDefined(template)) { + locals['$template'] = template; + } + return $q.all(locals); + } + } + + function getTemplateFor(route) { + var template, templateUrl; + if (angular.isDefined(template = route.template)) { + if (angular.isFunction(template)) { + template = template(route.params); + } + } else if (angular.isDefined(templateUrl = route.templateUrl)) { + if (angular.isFunction(templateUrl)) { + templateUrl = templateUrl(route.params); + } + if (angular.isDefined(templateUrl)) { + route.loadedTemplateUrl = $sce.valueOf(templateUrl); + template = $templateRequest(templateUrl); + } + } + return template; + } + + /** + * @returns {Object} the current active route, by matching it against the URL + */ + function parseRoute() { + // Match a route + var params, match; + angular.forEach(routes, function(route, path) { + if (!match && (params = switchRouteMatcher($location.path(), route))) { + match = inherit(route, { + params: angular.extend({}, $location.search(), params), + pathParams: params}); + match.$$route = route; + } + }); + // No route matched; fallback to "otherwise" route + return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}}); + } + + /** + * @returns {string} interpolation of the redirect path with the parameters + */ + function interpolate(string, params) { + var result = []; + angular.forEach((string || '').split(':'), function(segment, i) { + if (i === 0) { + result.push(segment); + } else { + var segmentMatch = segment.match(/(\w+)(?:[?*])?(.*)/); + var key = segmentMatch[1]; + result.push(params[key]); + result.push(segmentMatch[2] || ''); + delete params[key]; + } + }); + return result.join(''); + } + }]; +} + +instantiateRoute.$inject = ['$injector']; +function instantiateRoute($injector) { + if (isEagerInstantiationEnabled) { + // Instantiate `$route` + $injector.get('$route'); + } +} + +ngRouteModule.provider('$routeParams', $RouteParamsProvider); + + +/** + * @ngdoc service + * @name $routeParams + * @requires $route + * @this + * + * @description + * The `$routeParams` service allows you to retrieve the current set of route parameters. + * + * Requires the {@link ngRoute `ngRoute`} module to be installed. + * + * The route parameters are a combination of {@link ng.$location `$location`}'s + * {@link ng.$location#search `search()`} and {@link ng.$location#path `path()`}. + * The `path` parameters are extracted when the {@link ngRoute.$route `$route`} path is matched. + * + * In case of parameter name collision, `path` params take precedence over `search` params. + * + * The service guarantees that the identity of the `$routeParams` object will remain unchanged + * (but its properties will likely change) even when a route change occurs. + * + * Note that the `$routeParams` are only updated *after* a route change completes successfully. + * This means that you cannot rely on `$routeParams` being correct in route resolve functions. + * Instead you can use `$route.current.params` to access the new route's parameters. + * + * @example + * ```js + * // Given: + * // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby + * // Route: /Chapter/:chapterId/Section/:sectionId + * // + * // Then + * $routeParams ==> {chapterId:'1', sectionId:'2', search:'moby'} + * ``` + */ +function $RouteParamsProvider() { + this.$get = function() { return {}; }; +} + +ngRouteModule.directive('ngView', ngViewFactory); +ngRouteModule.directive('ngView', ngViewFillContentFactory); + + +/** + * @ngdoc directive + * @name ngView + * @restrict ECA + * + * @description + * # Overview + * `ngView` is a directive that complements the {@link ngRoute.$route $route} service by + * including the rendered template of the current route into the main layout (`index.html`) file. + * Every time the current route changes, the included view changes with it according to the + * configuration of the `$route` service. + * + * Requires the {@link ngRoute `ngRoute`} module to be installed. + * + * @animations + * | Animation | Occurs | + * |----------------------------------|-------------------------------------| + * | {@link ng.$animate#enter enter} | when the new element is inserted to the DOM | + * | {@link ng.$animate#leave leave} | when the old element is removed from to the DOM | + * + * The enter and leave animation occur concurrently. + * + * @scope + * @priority 400 + * @param {string=} onload Expression to evaluate whenever the view updates. + * + * @param {string=} autoscroll Whether `ngView` should call {@link ng.$anchorScroll + * $anchorScroll} to scroll the viewport after the view is updated. + * + * - If the attribute is not set, disable scrolling. + * - If the attribute is set without value, enable scrolling. + * - Otherwise enable scrolling only if the `autoscroll` attribute value evaluated + * as an expression yields a truthy value. + * @example + <example name="ngView-directive" module="ngViewExample" + deps="angular-route.js;angular-animate.js" + animations="true" fixBase="true"> + <file name="index.html"> + <div ng-controller="MainCtrl as main"> + Choose: + <a href="Book/Moby">Moby</a> | + <a href="Book/Moby/ch/1">Moby: Ch1</a> | + <a href="Book/Gatsby">Gatsby</a> | + <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> | + <a href="Book/Scarlet">Scarlet Letter</a><br/> + + <div class="view-animate-container"> + <div ng-view class="view-animate"></div> + </div> + <hr /> + + <pre>$location.path() = {{main.$location.path()}}</pre> + <pre>$route.current.templateUrl = {{main.$route.current.templateUrl}}</pre> + <pre>$route.current.params = {{main.$route.current.params}}</pre> + <pre>$routeParams = {{main.$routeParams}}</pre> + </div> + </file> + + <file name="book.html"> + <div> + controller: {{book.name}}<br /> + Book Id: {{book.params.bookId}}<br /> + </div> + </file> + + <file name="chapter.html"> + <div> + controller: {{chapter.name}}<br /> + Book Id: {{chapter.params.bookId}}<br /> + Chapter Id: {{chapter.params.chapterId}} + </div> + </file> + + <file name="animations.css"> + .view-animate-container { + position:relative; + height:100px!important; + background:white; + border:1px solid black; + height:40px; + overflow:hidden; + } + + .view-animate { + padding:10px; + } + + .view-animate.ng-enter, .view-animate.ng-leave { + transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s; + + display:block; + width:100%; + border-left:1px solid black; + + position:absolute; + top:0; + left:0; + right:0; + bottom:0; + padding:10px; + } + + .view-animate.ng-enter { + left:100%; + } + .view-animate.ng-enter.ng-enter-active { + left:0; + } + .view-animate.ng-leave.ng-leave-active { + left:-100%; + } + </file> + + <file name="script.js"> + angular.module('ngViewExample', ['ngRoute', 'ngAnimate']) + .config(['$routeProvider', '$locationProvider', + function($routeProvider, $locationProvider) { + $routeProvider + .when('/Book/:bookId', { + templateUrl: 'book.html', + controller: 'BookCtrl', + controllerAs: 'book' + }) + .when('/Book/:bookId/ch/:chapterId', { + templateUrl: 'chapter.html', + controller: 'ChapterCtrl', + controllerAs: 'chapter' + }); + + $locationProvider.html5Mode(true); + }]) + .controller('MainCtrl', ['$route', '$routeParams', '$location', + function MainCtrl($route, $routeParams, $location) { + this.$route = $route; + this.$location = $location; + this.$routeParams = $routeParams; + }]) + .controller('BookCtrl', ['$routeParams', function BookCtrl($routeParams) { + this.name = 'BookCtrl'; + this.params = $routeParams; + }]) + .controller('ChapterCtrl', ['$routeParams', function ChapterCtrl($routeParams) { + this.name = 'ChapterCtrl'; + this.params = $routeParams; + }]); + + </file> + + <file name="protractor.js" type="protractor"> + it('should load and compile correct template', function() { + element(by.linkText('Moby: Ch1')).click(); + var content = element(by.css('[ng-view]')).getText(); + expect(content).toMatch(/controller: ChapterCtrl/); + expect(content).toMatch(/Book Id: Moby/); + expect(content).toMatch(/Chapter Id: 1/); + + element(by.partialLinkText('Scarlet')).click(); + + content = element(by.css('[ng-view]')).getText(); + expect(content).toMatch(/controller: BookCtrl/); + expect(content).toMatch(/Book Id: Scarlet/); + }); + </file> + </example> + */ + + +/** + * @ngdoc event + * @name ngView#$viewContentLoaded + * @eventType emit on the current ngView scope + * @description + * Emitted every time the ngView content is reloaded. + */ +ngViewFactory.$inject = ['$route', '$anchorScroll', '$animate']; +function ngViewFactory($route, $anchorScroll, $animate) { + return { + restrict: 'ECA', + terminal: true, + priority: 400, + transclude: 'element', + link: function(scope, $element, attr, ctrl, $transclude) { + var currentScope, + currentElement, + previousLeaveAnimation, + autoScrollExp = attr.autoscroll, + onloadExp = attr.onload || ''; + + scope.$on('$routeChangeSuccess', update); + update(); + + function cleanupLastView() { + if (previousLeaveAnimation) { + $animate.cancel(previousLeaveAnimation); + previousLeaveAnimation = null; + } + + if (currentScope) { + currentScope.$destroy(); + currentScope = null; + } + if (currentElement) { + previousLeaveAnimation = $animate.leave(currentElement); + previousLeaveAnimation.done(function(response) { + if (response !== false) previousLeaveAnimation = null; + }); + currentElement = null; + } + } + + function update() { + var locals = $route.current && $route.current.locals, + template = locals && locals.$template; + + if (angular.isDefined(template)) { + var newScope = scope.$new(); + var current = $route.current; + + // Note: This will also link all children of ng-view that were contained in the original + // html. If that content contains controllers, ... they could pollute/change the scope. + // However, using ng-view on an element with additional content does not make sense... + // Note: We can't remove them in the cloneAttchFn of $transclude as that + // function is called before linking the content, which would apply child + // directives to non existing elements. + var clone = $transclude(newScope, function(clone) { + $animate.enter(clone, null, currentElement || $element).done(function onNgViewEnter(response) { + if (response !== false && angular.isDefined(autoScrollExp) + && (!autoScrollExp || scope.$eval(autoScrollExp))) { + $anchorScroll(); + } + }); + cleanupLastView(); + }); + + currentElement = clone; + currentScope = current.scope = newScope; + currentScope.$emit('$viewContentLoaded'); + currentScope.$eval(onloadExp); + } else { + cleanupLastView(); + } + } + } + }; +} + +// This directive is called during the $transclude call of the first `ngView` directive. +// It will replace and compile the content of the element with the loaded template. +// We need this directive so that the element content is already filled when +// the link function of another directive on the same element as ngView +// is called. +ngViewFillContentFactory.$inject = ['$compile', '$controller', '$route']; +function ngViewFillContentFactory($compile, $controller, $route) { + return { + restrict: 'ECA', + priority: -400, + link: function(scope, $element) { + var current = $route.current, + locals = current.locals; + + $element.html(locals.$template); + + var link = $compile($element.contents()); + + if (current.controller) { + locals.$scope = scope; + var controller = $controller(current.controller, locals); + if (current.controllerAs) { + scope[current.controllerAs] = controller; + } + $element.data('$ngControllerController', controller); + $element.children().data('$ngControllerController', controller); + } + scope[current.resolveAs || '$resolve'] = locals; + + link(scope); + } + }; +} + + +})(window, window.angular); diff --git a/vendor/assets/components/angular-route/angular-route.min.js b/vendor/assets/components/angular-route/angular-route.min.js new file mode 100644 index 0000000..7d1409b --- /dev/null +++ b/vendor/assets/components/angular-route/angular-route.min.js @@ -0,0 +1,17 @@ +/* + AngularJS v1.6.1 + (c) 2010-2016 Google, Inc. http://angularjs.org + License: MIT +*/ +(function(I,d){'use strict';function A(d){k&&d.get("$route")}function B(t,u,g){return{restrict:"ECA",terminal:!0,priority:400,transclude:"element",link:function(a,f,b,c,m){function v(){p&&(g.cancel(p),p=null);l&&(l.$destroy(),l=null);n&&(p=g.leave(n),p.done(function(a){!1!==a&&(p=null)}),n=null)}function D(){var b=t.current&&t.current.locals;if(d.isDefined(b&&b.$template)){var b=a.$new(),c=t.current;n=m(b,function(b){g.enter(b,null,n||f).done(function(b){!1===b||!d.isDefined(w)||w&&!a.$eval(w)||u()}); +v()});l=c.scope=b;l.$emit("$viewContentLoaded");l.$eval(k)}else v()}var l,n,p,w=b.autoscroll,k=b.onload||"";a.$on("$routeChangeSuccess",D);D()}}}function x(d,k,g){return{restrict:"ECA",priority:-400,link:function(a,f){var b=g.current,c=b.locals;f.html(c.$template);var m=d(f.contents());if(b.controller){c.$scope=a;var v=k(b.controller,c);b.controllerAs&&(a[b.controllerAs]=v);f.data("$ngControllerController",v);f.children().data("$ngControllerController",v)}a[b.resolveAs||"$resolve"]=c;m(a)}}}var y, +E,F,z=d.module("ngRoute",[]).provider("$route",function(){function t(a,f){return d.extend(Object.create(a),f)}function u(a,d){var b=d.caseInsensitiveMatch,c={originalPath:a,regexp:a},g=c.keys=[];a=a.replace(/([().])/g,"\\$1").replace(/(\/)?:(\w+)(\*\?|[?*])?/g,function(a,b,d,c){a="?"===c||"*?"===c?"?":null;c="*"===c||"*?"===c?"*":null;g.push({name:d,optional:!!a});b=b||"";return""+(a?"":b)+"(?:"+(a?b:"")+(c&&"(.+?)"||"([^/]+)")+(a||"")+")"+(a||"")}).replace(/([/$*])/g,"\\$1");c.regexp=new RegExp("^"+ +a+"$",b?"i":"");return c}y=d.isArray;E=d.isObject;F=d.isDefined;var g={};this.when=function(a,f){var b;b=void 0;if(y(f)){b=b||[];for(var c=0,m=f.length;c<m;c++)b[c]=f[c]}else if(E(f))for(c in b=b||{},f)if("$"!==c.charAt(0)||"$"!==c.charAt(1))b[c]=f[c];b=b||f;d.isUndefined(b.reloadOnSearch)&&(b.reloadOnSearch=!0);d.isUndefined(b.caseInsensitiveMatch)&&(b.caseInsensitiveMatch=this.caseInsensitiveMatch);g[a]=d.extend(b,a&&u(a,b));a&&(c="/"===a[a.length-1]?a.substr(0,a.length-1):a+"/",g[c]=d.extend({redirectTo:a}, +u(c,b)));return this};this.caseInsensitiveMatch=!1;this.otherwise=function(a){"string"===typeof a&&(a={redirectTo:a});this.when(null,a);return this};k=!0;this.eagerInstantiationEnabled=function(a){return F(a)?(k=a,this):k};this.$get=["$rootScope","$location","$routeParams","$q","$injector","$templateRequest","$sce",function(a,f,b,c,m,k,u){function l(e){var h=q.current;(y=(s=B())&&h&&s.$$route===h.$$route&&d.equals(s.pathParams,h.pathParams)&&!s.reloadOnSearch&&!C)||!h&&!s||a.$broadcast("$routeChangeStart", +s,h).defaultPrevented&&e&&e.preventDefault()}function n(){var e=q.current,h=s;if(y)e.params=h.params,d.copy(e.params,b),a.$broadcast("$routeUpdate",e);else if(h||e){C=!1;q.current=h;var G=c.resolve(h);G.then(p).then(w).then(function(c){return c&&G.then(z).then(function(c){h===q.current&&(h&&(h.locals=c,d.copy(h.params,b)),a.$broadcast("$routeChangeSuccess",h,e))})}).catch(function(b){h===q.current&&a.$broadcast("$routeChangeError",h,e,b)})}}function p(e){var a={route:e,hasRedirection:!1};if(e)if(e.redirectTo)if(d.isString(e.redirectTo))a.path= +x(e.redirectTo,e.params),a.search=e.params,a.hasRedirection=!0;else{var b=f.path(),g=f.search();e=e.redirectTo(e.pathParams,b,g);d.isDefined(e)&&(a.url=e,a.hasRedirection=!0)}else if(e.resolveRedirectTo)return c.resolve(m.invoke(e.resolveRedirectTo)).then(function(e){d.isDefined(e)&&(a.url=e,a.hasRedirection=!0);return a});return a}function w(a){var b=!0;if(a.route!==q.current)b=!1;else if(a.hasRedirection){var d=f.url(),c=a.url;c?f.url(c).replace():c=f.path(a.path).search(a.search).replace().url(); +c!==d&&(b=!1)}return b}function z(a){if(a){var b=d.extend({},a.resolve);d.forEach(b,function(a,e){b[e]=d.isString(a)?m.get(a):m.invoke(a,null,null,e)});a=A(a);d.isDefined(a)&&(b.$template=a);return c.all(b)}}function A(a){var b,c;d.isDefined(b=a.template)?d.isFunction(b)&&(b=b(a.params)):d.isDefined(c=a.templateUrl)&&(d.isFunction(c)&&(c=c(a.params)),d.isDefined(c)&&(a.loadedTemplateUrl=u.valueOf(c),b=k(c)));return b}function B(){var a,b;d.forEach(g,function(c,g){var r;if(r=!b){var k=f.path();r=c.keys; +var m={};if(c.regexp)if(k=c.regexp.exec(k)){for(var l=1,p=k.length;l<p;++l){var n=r[l-1],q=k[l];n&&q&&(m[n.name]=q)}r=m}else r=null;else r=null;r=a=r}r&&(b=t(c,{params:d.extend({},f.search(),a),pathParams:a}),b.$$route=c)});return b||g[null]&&t(g[null],{params:{},pathParams:{}})}function x(a,b){var c=[];d.forEach((a||"").split(":"),function(a,d){if(0===d)c.push(a);else{var e=a.match(/(\w+)(?:[?*])?(.*)/),f=e[1];c.push(b[f]);c.push(e[2]||"");delete b[f]}});return c.join("")}var C=!1,s,y,q={routes:g, +reload:function(){C=!0;var b={defaultPrevented:!1,preventDefault:function(){this.defaultPrevented=!0;C=!1}};a.$evalAsync(function(){l(b);b.defaultPrevented||n()})},updateParams:function(a){if(this.current&&this.current.$$route)a=d.extend({},this.current.params,a),f.path(x(this.current.$$route.originalPath,a)),f.search(a);else throw H("norout");}};a.$on("$locationChangeStart",l);a.$on("$locationChangeSuccess",n);return q}]}).run(A),H=d.$$minErr("ngRoute"),k;A.$inject=["$injector"];z.provider("$routeParams", +function(){this.$get=function(){return{}}});z.directive("ngView",B);z.directive("ngView",x);B.$inject=["$route","$anchorScroll","$animate"];x.$inject=["$compile","$controller","$route"]})(window,window.angular); +//# sourceMappingURL=angular-route.min.js.map diff --git a/vendor/assets/components/angular-route/angular-route.min.js.map b/vendor/assets/components/angular-route/angular-route.min.js.map new file mode 100644 index 0000000..ef4fcff --- /dev/null +++ b/vendor/assets/components/angular-route/angular-route.min.js.map @@ -0,0 +1,8 @@ +{ +"version":3, +"file":"angular-route.min.js", +"lineCount":16, +"mappings":"A;;;;;aAKC,SAAQ,CAACA,CAAD,CAASC,CAAT,CAAkB,CA62B3BC,QAASA,EAAgB,CAACC,CAAD,CAAY,CAC/BC,CAAJ,EAEED,CAAAE,IAAA,CAAc,QAAd,CAHiC,CAmOrCC,QAASA,EAAa,CAACC,CAAD,CAASC,CAAT,CAAwBC,CAAxB,CAAkC,CACtD,MAAO,CACLC,SAAU,KADL,CAELC,SAAU,CAAA,CAFL,CAGLC,SAAU,GAHL,CAILC,WAAY,SAJP,CAKLC,KAAMA,QAAQ,CAACC,CAAD,CAAQC,CAAR,CAAkBC,CAAlB,CAAwBC,CAAxB,CAA8BC,CAA9B,CAA2C,CAUrDC,QAASA,EAAe,EAAG,CACrBC,CAAJ,GACEZ,CAAAa,OAAA,CAAgBD,CAAhB,CACA,CAAAA,CAAA,CAAyB,IAF3B,CAKIE,EAAJ,GACEA,CAAAC,SAAA,EACA,CAAAD,CAAA,CAAe,IAFjB,CAIIE,EAAJ,GACEJ,CAIA,CAJyBZ,CAAAiB,MAAA,CAAeD,CAAf,CAIzB,CAHAJ,CAAAM,KAAA,CAA4B,QAAQ,CAACC,CAAD,CAAW,CAC5B,CAAA,CAAjB,GAAIA,CAAJ,GAAwBP,CAAxB,CAAiD,IAAjD,CAD6C,CAA/C,CAGA,CAAAI,CAAA,CAAiB,IALnB,CAVyB,CAmB3BI,QAASA,EAAM,EAAG,CAAA,IACZC,EAASvB,CAAAwB,QAATD,EAA2BvB,CAAAwB,QAAAD,OAG/B,IAAI7B,CAAA+B,UAAA,CAFWF,CAEX,EAFqBA,CAAAG,UAErB,CAAJ,CAAiC,CAC3BC,IAAAA,EAAWnB,CAAAoB,KAAA,EAAXD,CACAH,EAAUxB,CAAAwB,QAkBdN,EAAA,CAVYN,CAAAiB,CAAYF,CAAZE,CAAsB,QAAQ,CAACA,CAAD,CAAQ,CAChD3B,CAAA4B,MAAA,CAAeD,CAAf,CAAsB,IAAtB,CAA4BX,CAA5B,EAA8CT,CAA9C,CAAAW,KAAA,CAA6DW,QAAsB,CAACV,CAAD,CAAW,CAC3E,CAAA,CAAjB,GAAIA,CAAJ,EAA0B,CAAA3B,CAAA+B,UAAA,CAAkBO,CAAlB,CAA1B,EACOA,CADP,EACwB,CAAAxB,CAAAyB,MAAA,CAAYD,CAAZ,CADxB,EAEE/B,CAAA,EAH0F,CAA9F,CAMAY;CAAA,EAPgD,CAAtCgB,CAWZb,EAAA,CAAeQ,CAAAhB,MAAf,CAA+BmB,CAC/BX,EAAAkB,MAAA,CAAmB,oBAAnB,CACAlB,EAAAiB,MAAA,CAAmBE,CAAnB,CAvB+B,CAAjC,IAyBEtB,EAAA,EA7Bc,CA7BmC,IACjDG,CADiD,CAEjDE,CAFiD,CAGjDJ,CAHiD,CAIjDkB,EAAgBtB,CAAA0B,WAJiC,CAKjDD,EAAYzB,CAAA2B,OAAZF,EAA2B,EAE/B3B,EAAA8B,IAAA,CAAU,qBAAV,CAAiChB,CAAjC,CACAA,EAAA,EARqD,CALpD,CAD+C,CA6ExDiB,QAASA,EAAwB,CAACC,CAAD,CAAWC,CAAX,CAAwBzC,CAAxB,CAAgC,CAC/D,MAAO,CACLG,SAAU,KADL,CAELE,SAAW,IAFN,CAGLE,KAAMA,QAAQ,CAACC,CAAD,CAAQC,CAAR,CAAkB,CAAA,IAC1Be,EAAUxB,CAAAwB,QADgB,CAE1BD,EAASC,CAAAD,OAEbd,EAAAiC,KAAA,CAAcnB,CAAAG,UAAd,CAEA,KAAInB,EAAOiC,CAAA,CAAS/B,CAAAkC,SAAA,EAAT,CAEX,IAAInB,CAAAoB,WAAJ,CAAwB,CACtBrB,CAAAsB,OAAA,CAAgBrC,CAChB,KAAIoC,EAAaH,CAAA,CAAYjB,CAAAoB,WAAZ,CAAgCrB,CAAhC,CACbC,EAAAsB,aAAJ,GACEtC,CAAA,CAAMgB,CAAAsB,aAAN,CADF,CACgCF,CADhC,CAGAnC,EAAAsC,KAAA,CAAc,yBAAd,CAAyCH,CAAzC,CACAnC,EAAAuC,SAAA,EAAAD,KAAA,CAAyB,yBAAzB,CAAoDH,CAApD,CAPsB,CASxBpC,CAAA,CAAMgB,CAAAyB,UAAN,EAA2B,UAA3B,CAAA,CAAyC1B,CAEzChB,EAAA,CAAKC,CAAL,CAnB8B,CAH3B,CADwD,CA5nCjE,IAAI0C,CAAJ;AACIC,CADJ,CAEI1B,CAFJ,CAoBI2B,EAAgB1D,CAAA2D,OAAA,CACX,SADW,CACA,EADA,CAAAC,SAAA,CAET,QAFS,CA0BpBC,QAAuB,EAAG,CAKxBC,QAASA,EAAO,CAACC,CAAD,CAASC,CAAT,CAAgB,CAC9B,MAAOhE,EAAAiE,OAAA,CAAeC,MAAAC,OAAA,CAAcJ,CAAd,CAAf,CAAsCC,CAAtC,CADuB,CAoMhCI,QAASA,EAAU,CAACC,CAAD,CAAOC,CAAP,CAAa,CAAA,IAC1BC,EAAcD,CAAAE,qBADY,CAE1BC,EAAM,CACJC,aAAcL,CADV,CAEJM,OAAQN,CAFJ,CAFoB,CAM1BO,EAAOH,CAAAG,KAAPA,CAAkB,EAEtBP,EAAA,CAAOA,CAAAQ,QAAA,CACI,UADJ,CACgB,MADhB,CAAAA,QAAA,CAEI,0BAFJ,CAEgC,QAAQ,CAACC,CAAD,CAAIC,CAAJ,CAAWC,CAAX,CAAgBC,CAAhB,CAAwB,CAC/DC,CAAAA,CAAuB,GAAZ,GAACD,CAAD,EAA8B,IAA9B,GAAmBA,CAAnB,CAAsC,GAAtC,CAA4C,IACvDE,EAAAA,CAAmB,GAAZ,GAACF,CAAD,EAA8B,IAA9B,GAAmBA,CAAnB,CAAsC,GAAtC,CAA4C,IACvDL,EAAAQ,KAAA,CAAU,CAAEC,KAAML,CAAR,CAAaE,SAAU,CAAEA,CAAAA,CAAzB,CAAV,CACAH,EAAA,CAAQA,CAAR,EAAiB,EACjB,OAAO,EAAP,EACKG,CAAA,CAAW,EAAX,CAAgBH,CADrB,EAEI,KAFJ,EAGKG,CAAA,CAAWH,CAAX,CAAmB,EAHxB,GAIKI,CAJL,EAIa,OAJb,EAIwB,SAJxB,GAKKD,CALL,EAKiB,EALjB,EAMI,GANJ,EAOKA,CAPL,EAOiB,EAPjB,CALmE,CAFhE,CAAAL,QAAA,CAgBI,UAhBJ,CAgBgB,MAhBhB,CAkBPJ,EAAAE,OAAA,CAAa,IAAIW,MAAJ,CAAW,GAAX;AAAiBjB,CAAjB,CAAwB,GAAxB,CAA6BE,CAAA,CAAc,GAAd,CAAoB,EAAjD,CACb,OAAOE,EA3BuB,CAxMhCjB,CAAA,CAAUxD,CAAAwD,QACVC,EAAA,CAAWzD,CAAAyD,SACX1B,EAAA,CAAY/B,CAAA+B,UAMZ,KAAIwD,EAAS,EA6Ib,KAAAC,KAAA,CAAYC,QAAQ,CAACpB,CAAD,CAAOqB,CAAP,CAAc,CAEhC,IAAIC,CAAY,EAAA,CAAA,IAAA,EA7NlB,IAAInC,CAAA,CA6N0BkC,CA7N1B,CAAJ,CAAkB,CAChBE,CAAA,CAAMA,CAAN,EAAa,EAEb,KAHgB,IAGPC,EAAI,CAHG,CAGAC,EA0NYJ,CA1NPK,OAArB,CAAiCF,CAAjC,CAAqCC,CAArC,CAAyCD,CAAA,EAAzC,CACED,CAAA,CAAIC,CAAJ,CAAA,CAyN0BH,CAzNjB,CAAIG,CAAJ,CAJK,CAAlB,IAMO,IAAIpC,CAAA,CAuNmBiC,CAvNnB,CAAJ,CAGL,IAASV,CAAT,GAFAY,EAsN4BF,CAtNtBE,CAsNsBF,EAtNf,EAsNeA,CAAAA,CApN5B,CACE,GAAwB,GAAxB,GAAMV,CAAAgB,OAAA,CAAW,CAAX,CAAN,EAAiD,GAAjD,GAA+BhB,CAAAgB,OAAA,CAAW,CAAX,CAA/B,CACEJ,CAAA,CAAIZ,CAAJ,CAAA,CAkNwBU,CAlNb,CAAIV,CAAJ,CAKjB,EAAA,CAAOY,CAAP,EA6M8BF,CACxB1F,EAAAiG,YAAA,CAAoBN,CAAAO,eAApB,CAAJ,GACEP,CAAAO,eADF,CAC6B,CAAA,CAD7B,CAGIlG,EAAAiG,YAAA,CAAoBN,CAAAnB,qBAApB,CAAJ,GACEmB,CAAAnB,qBADF,CACmC,IAAAA,qBADnC,CAGAe,EAAA,CAAOlB,CAAP,CAAA,CAAerE,CAAAiE,OAAA,CACb0B,CADa,CAEbtB,CAFa,EAELD,CAAA,CAAWC,CAAX,CAAiBsB,CAAjB,CAFK,CAMXtB,EAAJ,GACM8B,CAIJ,CAJ8C,GAA3B,GAAC9B,CAAA,CAAKA,CAAA0B,OAAL,CAAmB,CAAnB,CAAD,CACX1B,CAAA+B,OAAA,CAAY,CAAZ,CAAe/B,CAAA0B,OAAf,CAA6B,CAA7B,CADW,CAEX1B,CAFW,CAEJ,GAEf,CAAAkB,CAAA,CAAOY,CAAP,CAAA,CAAuBnG,CAAAiE,OAAA,CACrB,CAACoC,WAAYhC,CAAb,CADqB;AAErBD,CAAA,CAAW+B,CAAX,CAAyBR,CAAzB,CAFqB,CALzB,CAWA,OAAO,KA1ByB,CAsClC,KAAAnB,qBAAA,CAA4B,CAAA,CAuD5B,KAAA8B,UAAA,CAAiBC,QAAQ,CAACC,CAAD,CAAS,CACV,QAAtB,GAAI,MAAOA,EAAX,GACEA,CADF,CACW,CAACH,WAAYG,CAAb,CADX,CAGA,KAAAhB,KAAA,CAAU,IAAV,CAAgBgB,CAAhB,CACA,OAAO,KALyB,CAuClCrG,EAAA,CAA8B,CAAA,CAC9B,KAAAsG,0BAAA,CAAiCC,QAAkC,CAACC,CAAD,CAAU,CAC3E,MAAI5E,EAAA,CAAU4E,CAAV,CAAJ,EACExG,CACO,CADuBwG,CACvB,CAAA,IAFT,EAKOxG,CANoE,CAU7E,KAAAyG,KAAA,CAAY,CAAC,YAAD,CACC,WADD,CAEC,cAFD,CAGC,IAHD,CAIC,WAJD,CAKC,kBALD,CAMC,MAND,CAOR,QAAQ,CAACC,CAAD,CAAaC,CAAb,CAAwBC,CAAxB,CAAsCC,CAAtC,CAA0C9G,CAA1C,CAAqD+G,CAArD,CAAuEC,CAAvE,CAA6E,CA2SvFC,QAASA,EAAY,CAACC,CAAD,CAAiB,CACpC,IAAIC,EAAY/G,CAAAwB,QAOhB,EAJAwF,CAIA,EALAC,CAKA,CALgBC,CAAA,EAKhB,GAJ6CH,CAI7C,EAJ0DE,CAAAE,QAI1D,GAJoFJ,CAAAI,QAIpF,EAHOzH,CAAA0H,OAAA,CAAeH,CAAAI,WAAf,CAAyCN,CAAAM,WAAzC,CAGP,EAFO,CAACJ,CAAArB,eAER,EAFwC,CAAC0B,CAEzC,GAAmCP,CAAAA,CAAnC,EAAgDE,CAAAA,CAAhD,EACMV,CAAAgB,WAAA,CAAsB,mBAAtB;AAA2CN,CAA3C,CAA0DF,CAA1D,CAAAS,iBADN,EAEQV,CAFR,EAGMA,CAAAW,eAAA,EAX8B,CAiBtCC,QAASA,EAAW,EAAG,CACrB,IAAIX,EAAY/G,CAAAwB,QAAhB,CACImG,EAAYV,CAEhB,IAAID,CAAJ,CACED,CAAAb,OAEA,CAFmByB,CAAAzB,OAEnB,CADAxG,CAAAkI,KAAA,CAAab,CAAAb,OAAb,CAA+BO,CAA/B,CACA,CAAAF,CAAAgB,WAAA,CAAsB,cAAtB,CAAsCR,CAAtC,CAHF,KAIO,IAAIY,CAAJ,EAAiBZ,CAAjB,CAA4B,CACjCO,CAAA,CAAc,CAAA,CACdtH,EAAAwB,QAAA,CAAiBmG,CAEjB,KAAIE,EAAmBnB,CAAAoB,QAAA,CAAWH,CAAX,CAEvBE,EAAAE,KAAA,CACOC,CADP,CAAAD,KAAA,CAEOE,CAFP,CAAAF,KAAA,CAGO,QAAQ,CAACG,CAAD,CAAsB,CACjC,MAAOA,EAAP,EAA8BL,CAAAE,KAAA,CACvBI,CADuB,CAAAJ,KAAA,CAEvB,QAAQ,CAACxG,CAAD,CAAS,CAEhBoG,CAAJ,GAAkB3H,CAAAwB,QAAlB,GACMmG,CAIJ,GAHEA,CAAApG,OACA,CADmBA,CACnB,CAAA7B,CAAAkI,KAAA,CAAaD,CAAAzB,OAAb,CAA+BO,CAA/B,CAEF,EAAAF,CAAAgB,WAAA,CAAsB,qBAAtB,CAA6CI,CAA7C,CAAwDZ,CAAxD,CALF,CAFoB,CAFM,CADG,CAHrC,CAAAqB,MAAA,CAgBW,QAAQ,CAACC,CAAD,CAAQ,CACnBV,CAAJ,GAAkB3H,CAAAwB,QAAlB,EACE+E,CAAAgB,WAAA,CAAsB,mBAAtB,CAA2CI,CAA3C,CAAsDZ,CAAtD,CAAiEsB,CAAjE,CAFqB,CAhB3B,CANiC,CARd,CAsCvBL,QAASA,EAAkB,CAAC5C,CAAD,CAAQ,CACjC,IAAIrC,EAAO,CACTqC,MAAOA,CADE,CAETkD,eAAgB,CAAA,CAFP,CAKX,IAAIlD,CAAJ,CACE,GAAIA,CAAAW,WAAJ,CACE,GAAIrG,CAAA6I,SAAA,CAAiBnD,CAAAW,WAAjB,CAAJ,CACEhD,CAAAgB,KAEA;AAFYyE,CAAA,CAAYpD,CAAAW,WAAZ,CAA8BX,CAAAc,OAA9B,CAEZ,CADAnD,CAAA0F,OACA,CADcrD,CAAAc,OACd,CAAAnD,CAAAuF,eAAA,CAAsB,CAAA,CAHxB,KAIO,CACL,IAAII,EAAUlC,CAAAzC,KAAA,EAAd,CACI4E,EAAYnC,CAAAiC,OAAA,EACZG,EAAAA,CAASxD,CAAAW,WAAA,CAAiBX,CAAAiC,WAAjB,CAAmCqB,CAAnC,CAA4CC,CAA5C,CAETjJ,EAAA+B,UAAA,CAAkBmH,CAAlB,CAAJ,GACE7F,CAAA8F,IACA,CADWD,CACX,CAAA7F,CAAAuF,eAAA,CAAsB,CAAA,CAFxB,CALK,CALT,IAeO,IAAIlD,CAAA0D,kBAAJ,CACL,MAAOpC,EAAAoB,QAAA,CACGlI,CAAAmJ,OAAA,CAAiB3D,CAAA0D,kBAAjB,CADH,CAAAf,KAAA,CAEA,QAAQ,CAACa,CAAD,CAAS,CAChBlJ,CAAA+B,UAAA,CAAkBmH,CAAlB,CAAJ,GACE7F,CAAA8F,IACA,CADWD,CACX,CAAA7F,CAAAuF,eAAA,CAAsB,CAAA,CAFxB,CAKA,OAAOvF,EANa,CAFjB,CAaX,OAAOA,EApC0B,CAuCnCkF,QAASA,EAAyB,CAAClF,CAAD,CAAO,CACvC,IAAImF,EAAsB,CAAA,CAE1B,IAAInF,CAAAqC,MAAJ,GAAmBpF,CAAAwB,QAAnB,CACE0G,CAAA,CAAsB,CAAA,CADxB,KAEO,IAAInF,CAAAuF,eAAJ,CAAyB,CAC9B,IAAIU,EAASxC,CAAAqC,IAAA,EAAb,CACID,EAAS7F,CAAA8F,IAETD,EAAJ,CACEpC,CAAAqC,IAAA,CACMD,CADN,CAAArE,QAAA,EADF,CAKEqE,CALF,CAKWpC,CAAAzC,KAAA,CACFhB,CAAAgB,KADE,CAAA0E,OAAA,CAEA1F,CAAA0F,OAFA,CAAAlE,QAAA,EAAAsE,IAAA,EAOPD;CAAJ,GAAeI,CAAf,GAGEd,CAHF,CAGwB,CAAA,CAHxB,CAhB8B,CAuBhC,MAAOA,EA5BgC,CA+BzCC,QAASA,EAAa,CAAC/C,CAAD,CAAQ,CAC5B,GAAIA,CAAJ,CAAW,CACT,IAAI7D,EAAS7B,CAAAiE,OAAA,CAAe,EAAf,CAAmByB,CAAA0C,QAAnB,CACbpI,EAAAuJ,QAAA,CAAgB1H,CAAhB,CAAwB,QAAQ,CAAC2H,CAAD,CAAQxE,CAAR,CAAa,CAC3CnD,CAAA,CAAOmD,CAAP,CAAA,CAAchF,CAAA6I,SAAA,CAAiBW,CAAjB,CAAA,CACVtJ,CAAAE,IAAA,CAAcoJ,CAAd,CADU,CAEVtJ,CAAAmJ,OAAA,CAAiBG,CAAjB,CAAwB,IAAxB,CAA8B,IAA9B,CAAoCxE,CAApC,CAHuC,CAA7C,CAKIyE,EAAAA,CAAWC,CAAA,CAAehE,CAAf,CACX1F,EAAA+B,UAAA,CAAkB0H,CAAlB,CAAJ,GACE5H,CAAA,UADF,CACwB4H,CADxB,CAGA,OAAOzC,EAAA2C,IAAA,CAAO9H,CAAP,CAXE,CADiB,CAgB9B6H,QAASA,EAAc,CAAChE,CAAD,CAAQ,CAAA,IACzB+D,CADyB,CACfG,CACV5J,EAAA+B,UAAA,CAAkB0H,CAAlB,CAA6B/D,CAAA+D,SAA7B,CAAJ,CACMzJ,CAAA6J,WAAA,CAAmBJ,CAAnB,CADN,GAEIA,CAFJ,CAEeA,CAAA,CAAS/D,CAAAc,OAAT,CAFf,EAIWxG,CAAA+B,UAAA,CAAkB6H,CAAlB,CAAgClE,CAAAkE,YAAhC,CAJX,GAKM5J,CAAA6J,WAAA,CAAmBD,CAAnB,CAGJ,GAFEA,CAEF,CAFgBA,CAAA,CAAYlE,CAAAc,OAAZ,CAEhB,EAAIxG,CAAA+B,UAAA,CAAkB6H,CAAlB,CAAJ,GACElE,CAAAoE,kBACA,CAD0B5C,CAAA6C,QAAA,CAAaH,CAAb,CAC1B,CAAAH,CAAA,CAAWxC,CAAA,CAAiB2C,CAAjB,CAFb,CARF,CAaA,OAAOH,EAfsB,CAqB/BjC,QAASA,EAAU,EAAG,CAAA,IAEhBhB,CAFgB,CAERwD,CACZhK,EAAAuJ,QAAA,CAAgBhE,CAAhB,CAAwB,QAAQ,CAACG,CAAD,CAAQrB,CAAR,CAAc,CACxC,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAW,IAAA,EAAA,CAAA,KAAA,EA1LbO,EAAAA,CA0Lac,CA1LNd,KAAX;IACI4B,EAAS,EAEb,IAuLiBd,CAvLZf,OAAL,CAGA,GADIsF,CACJ,CAoLiBvE,CArLTf,OAAAuF,KAAA,CAAkBC,CAAlB,CACR,CAAA,CAEA,IATqC,IAS5BtE,EAAI,CATwB,CASrBuE,EAAMH,CAAAlE,OAAtB,CAAgCF,CAAhC,CAAoCuE,CAApC,CAAyC,EAAEvE,CAA3C,CAA8C,CAC5C,IAAIb,EAAMJ,CAAA,CAAKiB,CAAL,CAAS,CAAT,CAAV,CAEIwE,EAAMJ,CAAA,CAAEpE,CAAF,CAENb,EAAJ,EAAWqF,CAAX,GACE7D,CAAA,CAAOxB,CAAAK,KAAP,CADF,CACqBgF,CADrB,CAL4C,CAS9C,CAAA,CAAO7D,CAXP,CAAA,IAAQ,EAAA,CAAO,IAHf,KAAmB,EAAA,CAAO,IAuLT,EAAA,CAAA,CAAA,CAAA,CAAX,CAAA,CAAJ,GACEwD,CAGA,CAHQlG,CAAA,CAAQ4B,CAAR,CAAe,CACrBc,OAAQxG,CAAAiE,OAAA,CAAe,EAAf,CAAmB6C,CAAAiC,OAAA,EAAnB,CAAuCvC,CAAvC,CADa,CAErBmB,WAAYnB,CAFS,CAAf,CAGR,CAAAwD,CAAAvC,QAAA,CAAgB/B,CAJlB,CAD4C,CAA9C,CASA,OAAOsE,EAAP,EAAgBzE,CAAA,CAAO,IAAP,CAAhB,EAAgCzB,CAAA,CAAQyB,CAAA,CAAO,IAAP,CAAR,CAAsB,CAACiB,OAAQ,EAAT,CAAamB,WAAW,EAAxB,CAAtB,CAZZ,CAkBtBmB,QAASA,EAAW,CAACwB,CAAD,CAAS9D,CAAT,CAAiB,CACnC,IAAI+D,EAAS,EACbvK,EAAAuJ,QAAA,CAAgBiB,CAACF,CAADE,EAAW,EAAXA,OAAA,CAAqB,GAArB,CAAhB,CAA2C,QAAQ,CAACC,CAAD,CAAU5E,CAAV,CAAa,CAC9D,GAAU,CAAV,GAAIA,CAAJ,CACE0E,CAAAnF,KAAA,CAAYqF,CAAZ,CADF,KAEO,CACL,IAAIC,EAAeD,CAAAT,MAAA,CAAc,oBAAd,CAAnB,CACIhF,EAAM0F,CAAA,CAAa,CAAb,CACVH,EAAAnF,KAAA,CAAYoB,CAAA,CAAOxB,CAAP,CAAZ,CACAuF,EAAAnF,KAAA,CAAYsF,CAAA,CAAa,CAAb,CAAZ,EAA+B,EAA/B,CACA,QAAOlE,CAAA,CAAOxB,CAAP,CALF,CAHuD,CAAhE,CAWA,OAAOuF,EAAAI,KAAA,CAAY,EAAZ,CAb4B,CA/dkD,IAyMnF/C,EAAc,CAAA,CAzMqE,CA0MnFL,CA1MmF,CA2MnFD,CA3MmF,CA4MnFhH,EAAS,CACPiF,OAAQA,CADD;AAcPqF,OAAQA,QAAQ,EAAG,CACjBhD,CAAA,CAAc,CAAA,CAEd,KAAIiD,EAAoB,CACtB/C,iBAAkB,CAAA,CADI,CAEtBC,eAAgB+C,QAA2B,EAAG,CAC5C,IAAAhD,iBAAA,CAAwB,CAAA,CACxBF,EAAA,CAAc,CAAA,CAF8B,CAFxB,CAQxBf,EAAAkE,WAAA,CAAsB,QAAQ,EAAG,CAC/B5D,CAAA,CAAa0D,CAAb,CACKA,EAAA/C,iBAAL,EAAyCE,CAAA,EAFV,CAAjC,CAXiB,CAdZ,CA4CPgD,aAAcA,QAAQ,CAACC,CAAD,CAAY,CAChC,GAAI,IAAAnJ,QAAJ,EAAoB,IAAAA,QAAA2F,QAApB,CACEwD,CAGA,CAHYjL,CAAAiE,OAAA,CAAe,EAAf,CAAmB,IAAAnC,QAAA0E,OAAnB,CAAwCyE,CAAxC,CAGZ,CAFAnE,CAAAzC,KAAA,CAAeyE,CAAA,CAAY,IAAAhH,QAAA2F,QAAA/C,aAAZ,CAA+CuG,CAA/C,CAAf,CAEA,CAAAnE,CAAAiC,OAAA,CAAiBkC,CAAjB,CAJF,KAME,MAAMC,EAAA,CAAa,QAAb,CAAN,CAP8B,CA5C3B,CAwDbrE,EAAAjE,IAAA,CAAe,sBAAf,CAAuCuE,CAAvC,CACAN,EAAAjE,IAAA,CAAe,wBAAf,CAAyCoF,CAAzC,CAEA,OAAO1H,EAvQgF,CAP7E,CArSY,CA1BN,CAAA6K,IAAA,CAMdlL,CANc,CApBpB,CA2BIiL,EAAelL,CAAAoL,SAAA,CAAiB,SAAjB,CA3BnB,CA4BIjL,CA+yBJF,EAAAoL,QAAA,CAA2B,CAAC,WAAD,CAQ3B3H,EAAAE,SAAA,CAAuB,cAAvB;AAqCA0H,QAA6B,EAAG,CAC9B,IAAA1E,KAAA,CAAY2E,QAAQ,EAAG,CAAE,MAAO,EAAT,CADO,CArChC,CAyCA7H,EAAA8H,UAAA,CAAwB,QAAxB,CAAkCnL,CAAlC,CACAqD,EAAA8H,UAAA,CAAwB,QAAxB,CAAkC3I,CAAlC,CAiLAxC,EAAAgL,QAAA,CAAwB,CAAC,QAAD,CAAW,eAAX,CAA4B,UAA5B,CA6ExBxI,EAAAwI,QAAA,CAAmC,CAAC,UAAD,CAAa,aAAb,CAA4B,QAA5B,CA5pCR,CAA1B,CAAD,CA0rCGtL,MA1rCH,CA0rCWA,MAAAC,QA1rCX;", +"sources":["angular-route.js"], +"names":["window","angular","instantiateRoute","$injector","isEagerInstantiationEnabled","get","ngViewFactory","$route","$anchorScroll","$animate","restrict","terminal","priority","transclude","link","scope","$element","attr","ctrl","$transclude","cleanupLastView","previousLeaveAnimation","cancel","currentScope","$destroy","currentElement","leave","done","response","update","locals","current","isDefined","$template","newScope","$new","clone","enter","onNgViewEnter","autoScrollExp","$eval","$emit","onloadExp","autoscroll","onload","$on","ngViewFillContentFactory","$compile","$controller","html","contents","controller","$scope","controllerAs","data","children","resolveAs","isArray","isObject","ngRouteModule","module","provider","$RouteProvider","inherit","parent","extra","extend","Object","create","pathRegExp","path","opts","insensitive","caseInsensitiveMatch","ret","originalPath","regexp","keys","replace","_","slash","key","option","optional","star","push","name","RegExp","routes","when","this.when","route","routeCopy","dst","i","ii","length","charAt","isUndefined","reloadOnSearch","redirectPath","substr","redirectTo","otherwise","this.otherwise","params","eagerInstantiationEnabled","this.eagerInstantiationEnabled","enabled","$get","$rootScope","$location","$routeParams","$q","$templateRequest","$sce","prepareRoute","$locationEvent","lastRoute","preparedRouteIsUpdateOnly","preparedRoute","parseRoute","$$route","equals","pathParams","forceReload","$broadcast","defaultPrevented","preventDefault","commitRoute","nextRoute","copy","nextRoutePromise","resolve","then","getRedirectionData","handlePossibleRedirection","keepProcessingRoute","resolveLocals","catch","error","hasRedirection","isString","interpolate","search","oldPath","oldSearch","newUrl","url","resolveRedirectTo","invoke","oldUrl","forEach","value","template","getTemplateFor","all","templateUrl","isFunction","loadedTemplateUrl","valueOf","match","m","exec","on","len","val","string","result","split","segment","segmentMatch","join","reload","fakeLocationEvent","fakePreventDefault","$evalAsync","updateParams","newParams","$routeMinErr","run","$$minErr","$inject","$RouteParamsProvider","this.$get","directive"] +} diff --git a/vendor/assets/components/angular-route/bower.json b/vendor/assets/components/angular-route/bower.json new file mode 100644 index 0000000..25e13cc --- /dev/null +++ b/vendor/assets/components/angular-route/bower.json @@ -0,0 +1,10 @@ +{ + "name": "angular-route", + "version": "1.6.1", + "license": "MIT", + "main": "./angular-route.js", + "ignore": [], + "dependencies": { + "angular": "1.6.1" + } +} diff --git a/vendor/assets/components/angular-route/index.js b/vendor/assets/components/angular-route/index.js new file mode 100644 index 0000000..9ed2645 --- /dev/null +++ b/vendor/assets/components/angular-route/index.js @@ -0,0 +1,2 @@ +require('./angular-route'); +module.exports = 'ngRoute'; diff --git a/vendor/assets/components/angular-route/package.json b/vendor/assets/components/angular-route/package.json new file mode 100644 index 0000000..d0fc039 --- /dev/null +++ b/vendor/assets/components/angular-route/package.json @@ -0,0 +1,33 @@ +{ + "name": "angular-route", + "version": "1.6.1", + "description": "AngularJS router module", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "https://github.com/angular/angular.js.git" + }, + "keywords": [ + "angular", + "framework", + "browser", + "router", + "client-side" + ], + "author": "Angular Core Team <angular-core+npm@google.com>", + "license": "MIT", + "bugs": { + "url": "https://github.com/angular/angular.js/issues" + }, + "homepage": "http://angularjs.org", + "jspm": { + "shim": { + "angular-route": { + "deps": ["angular"] + } + } + } +} |