Showing preview only (4,595K chars total). Download the full file or copy to clipboard to get everything.
Repository: ShMcK/WebpackAngularDemos
Branch: master
Commit: 87abc93f5495
Files: 38
Total size: 4.4 MB
Directory structure:
gitextract_x5zzdzpb/
├── .gitignore
├── Part1/
│ ├── .jshintrc
│ ├── README.md
│ ├── app/
│ │ ├── bundle.js
│ │ ├── core/
│ │ │ ├── bootstrap.js
│ │ │ └── vendor.js
│ │ ├── index.html
│ │ ├── index.js
│ │ └── index.scss
│ ├── package.json
│ └── webpack.config.js
├── Part2/
│ ├── .jshintrc
│ ├── README.md
│ ├── app/
│ │ ├── bundle.js
│ │ ├── core/
│ │ │ ├── bootstrap.js
│ │ │ └── vendor.js
│ │ ├── index.html
│ │ ├── index.js
│ │ └── index.scss
│ ├── package.json
│ └── webpack.config.js
├── Part3/
│ ├── .jshintrc
│ ├── README.md
│ ├── app/
│ │ ├── bundle.js
│ │ ├── core/
│ │ │ ├── bootstrap.js
│ │ │ ├── config/
│ │ │ │ └── production.js
│ │ │ ├── layout.js
│ │ │ ├── nav/
│ │ │ │ ├── nav.html
│ │ │ │ ├── nav.js
│ │ │ │ └── nav.scss
│ │ │ └── vendor.js
│ │ ├── index.html
│ │ ├── index.js
│ │ ├── index.json
│ │ └── index.scss
│ ├── package.json
│ └── webpack.config.js
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.idea
Part1/node_modules
Part2/node_modules
Part3/node_modules
Part2/app/bower_components
Part3/app/bower_components
Part1/npm-debug.log
Part2/npm-debug.log
Part3/npm-debug.log
================================================
FILE: Part1/.jshintrc
================================================
{
"esnext": true,
"node": true,
"globals": {
"angular": true,
"console": true
}
}
================================================
FILE: Part1/README.md
================================================
##### Part 1
<div class="update">Updated Jan 16th, 2016.</div>
# Getting Started
There are a lot of module loaders out there: Require.js, JSPM using System.js, to name a few.
Eventually the JavaScript community will come around and land on a winning module loader. My guess is Webpack, or something very similar.
Go with Webpack. Webpack provides an elegant and multi-featured approach to module loading. It does everything I wanted it to do, and more. Really, a lot more.
Let's try it out. We'll setup a project using Webpack, including ES6 transpiling & Sass loading. In this example, we'll setup an Angular based project using Webpack.
<center></center>
Free free to load the [basic project from Github](https://github.com/ShMcK/WebpackAngularDemos/tree/master/Part1).
## File Setup
File Structure:
```
root
├── app
│ ├── core
│ │ ├──bootstrap.js
│ │ └──vendor.js
│ │
│ ├── index.html
│ ├── index.scss
│ └──index.js
├── .jshintrc
├── node_modules
└── package.json
```
This should be the bare minimum required to check if everything is working.
/app/index.html
```markup
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Webpack & Angular</title>
</head>
<body>
<p>Angular is working: {{1 + 1 === 2}}</p>
<script src="bundle.js"></script>
</body>
</html>
```
/app/index.js
```js
alert('loaded!');
```
## Webpack
### Setup
Let's create a `package.json` file to get started.
```shell
npm init
```
Agree to whatever defaults.
We're going to need a few basic dev-dependencies to get started with webpack.
```shell
npm install -D webpack
```
Webpack will also require a [webpack configuration file](http://webpack.github.io/docs/configuration.html): `webpack.config.js`. Make the file and add the following:
/webpack.config.js
```js
'use strict';
var webpack = require('webpack'),
path = require('path');
var APP = __dirname + '/app';
module.exports = {
// config goes here
};
```
Webpack is a lot easier than it looks. You just need to provide an `entry` and an `output`.
Notice `bundle.js` is the only script we needed to load in our `index.html`. Everything will go into that bundle.
Later you can have multiple bundles for easy lazy-loading and code-splitting.
/webpack.config.js
```js
module.exports = {
context: APP,
entry: {
app: './index.js'
},
output: {
path: APP,
filename: 'bundle.js'
}
}
```
We now have a module loader.
Let's build our bundle in the terminal.
```shell
webpack
```
This should create the `app/bundle.js` file. Check it out. It's mostly a bunch of `webpack__require` statements.
### Webpack-Dev-Server
[Webpack-dev-server](http://webpack.github.io/docs/webpack-dev-server.html) is a quick and easy Node.js/Express/Socket.io app that creates your `bundle.js` file on the fly and reloads it on changes.
Install it as a dev-dependency.
```shell
npm install -D webpack-dev-server
```
But wait, there's more!
### Hot Mode
Hot mode = live-reload of modules. No need to reload the entire project on every change, just load what changed. It makes sense and it's awesome.
It's not much work either. Update your webpack.config file.
/webpack.config.js
```js
entry: {
app: ['webpack/hot/dev-server', './index.js']
}
```
You may want to install `webpack-dev-server` globally. Otherwise you'll have to run it the long way: `node node_modules/.bin/webpack-dev-server --content-base app/ --hot`
Run it.
```shell
npm install -g webpack-dev-server
webpack-dev-server --content-base app/ --hot
```
Open up `http://localhost:8080/webpack-dev-server/`.
It's hot.
/app/index.js
```js
alert('hot-loaded!');
```
It updates amazingly fast. Again, unlike Gulp or Grunt, Webpack only needs to re-compile the module that changed.
Targeted reloading might not be important to you now, but as your project grows in size & complexity it becomes increasingly useful.
### Quick Start
If you're used to using Gulp or Grunt, you probably like the time saving `gulp serve`, `grunt serve` shortcuts for running your app.
This can be accomplished with `package.json` [scripts](https://docs.npmjs.com/misc/scripts).
/package.json
```json
"scripts": {
"start": "webpack-dev-server --content-base app --hot"
}
```
Now run `npm start`. Again, the app can be found at `localhost:8080/` by default, or `localhost:8080/webpack-dev-server` for the hot-module version.
#### Bootstrap Angular
I like to bootstrap Angular, rather than adding `ng-app="app"` into the html.
/app/core/bootstrap.js
```js
/*jshint browser:true */
'use strict';
// load Angular
require('angular');
// load the main app file
var appModule = require('../index');
// replaces ng-app="appName"
angular.element(document).ready(function () {
angular.bootstrap(document, [appModule.name], {
//strictDi: true
});
});
```
Notice `require('angular')`? That replaces adding `<script src="bower_components/angular/angular.min.js">`. No need for that, this is a module system.
Also note that `appModule.name` will be taken from `index.js`, whatever its name might be: `angular.module('THISNAMEHERE', [])`.
Make the app file: `index.js`.
/app/index.js
```js
module.exports = angular.module('app', []);
```
Finally, let's make `bootstrap.js` our new Webpack entry point.
/webpack.config.js
```js
entry: {
app: ['webpack/hot/dev-server', './core/bootstrap.js']
}
```
Run the app (`npm start`). If all went well, running the app you should see: "Angular is working: true" at `localhost:8080` or `localhost:8080/webpack-dev-server`.
#### Add Dependencies
Install angular.
`npm install --save angular`
Bootstrap will get messy if we keep loading all our dependencies in there. Let's load them in a separate file called `vendor.js`.
/app/core/bootstrap.js
```js
require(./vendor')(); // run an empty function
var appModule = require('../index');
```
/app/core/vendor.js
```js
module.exports = function () {
/* JS */
require('angular');
};
```
This file will get longer later.
#### Styles
Webpack doesn't just load JavaScript, it can load nearly anything we might need: styles, images, fonts, etc.
It handles these different file formats using [loaders](http://webpack.github.io/docs/using-loaders.html). Here's [a list of available loaders](http://webpack.github.io/docs/list-of-loaders.html).
Let's start with the Style, CSS, and Sass loaders and install them as dev-dependencies.
```shell
npm install -D style-loader css-loader sass-loader`
```
Webpack can use a Regex test to determine which loader to use. Add this to your webpack.config.js file.
/webpack.config.js
```js
module.exports = {
/* context, entry, output */
module: {
loaders: [
{
test: /\.scss$/,
loader: 'style!css!sass'
}
]
}
};
```
Loaders process from right to left. Meaning that if a `.scss` file is required as in the example, it will follow this order: sass loader => css loader => style loader
Run a quick test with a style sheet.
/app/index.scss
```scss
body {
background-color: red;
}
```
Require the file.
/app/core/vendor.js
```js
module.exports = {
/* Styles */
require('../index.scss');
/* JS */
require('angular');
}
```
Take a look, `npm start`, the background should now be red.
#### ES6 Loaders
Webpack makes it easy to use compiled languages like ES6, TypeScript, CoffeeScript, etc. Let's write our app in ES6 and compile it to ES5/ES3.
First we need some loaders. Install the dev-dependencies:
`npm install -D jshint-loader babel-loader ng-annotate-loader babel-preset-es2015`
As before, we provide a loader object with a pattern matching test case. We'll exclude compiling packages.
/webpack.config.js
```js
loaders: [
{
test: /\.js$/,
loader: 'ng-annotate!babel?presets[]=es2015!jshint',
exclude: /node_modules|bower_components/
}
]
```
Webpack will take any required `.js` files, and run them right to left: jshint => babel => ng-annotate.
In Babel you must now specify the preset you are using, in this case 'es2015'. This allows Babel to be much more flexible with future js versions.
Let's use an ES6 example to make sure everything is working.
/app/index.js
```js
module.exports = angular.module('app', []);
// default params
function printMessage (status='working') {
// let
let message = 'ES6';
// template string
console.log(`${message} is ${status}`);
}
printMessage();
```
Run the app, `npm start`, and you should see "ES6 is working" in the console.
#### Removing JSHint Errors
You probably saw some warnings (in yellow) when you ran the app.
You might want to remove these warnings from the console caused by jshint using a `.jshintrc` file. You can take [Jon Papa's recommended .jshintrc](https://github.com/johnpapa/angular-styleguide#js-hint) or add the following:
/.jshintrc
```json
{
"esnext": true,
"node": true,
"globals": {
"angular": true,
"console": true
}
}
```
## Conclusion
When I made my first webpack app, I was left wondering:
> What happened to the build stage?
> Where's the heavy lifting we need Grunt/Gulp for?
But it's all in the few lines of code in that webpack.config file. The app is built everytime you run `webpack`, and built and updated on the fly when you run the `webpack-dev-server`.
Everything goes in the bundle.js. It fits my criteria for a good module loader: it's simple and it works.
Granted, this was a simple use case. We'll look at how Webpack handles more complicated cases in the [next post](http://shmck.com/webpack-angular-part-2), as we setup a project requiring [LumX](http://ui.lumapps.com/), a popular Material Design based CSS Framework for Angular.
================================================
FILE: Part1/app/bundle.js
================================================
/******/ (function(modules) { // webpackBootstrap
/******/ var parentHotUpdateCallback = this["webpackHotUpdate"];
/******/ this["webpackHotUpdate"] =
/******/ function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars
/******/ hotAddUpdateChunk(chunkId, moreModules);
/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
/******/ }
/******/
/******/ function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
/******/ var head = document.getElementsByTagName("head")[0];
/******/ var script = document.createElement("script");
/******/ script.type = "text/javascript";
/******/ script.charset = "utf-8";
/******/ script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
/******/ head.appendChild(script);
/******/ }
/******/
/******/ function hotDownloadManifest(callback) { // eslint-disable-line no-unused-vars
/******/ if(typeof XMLHttpRequest === "undefined")
/******/ return callback(new Error("No browser support"));
/******/ try {
/******/ var request = new XMLHttpRequest();
/******/ var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json";
/******/ request.open("GET", requestPath, true);
/******/ request.timeout = 10000;
/******/ request.send(null);
/******/ } catch(err) {
/******/ return callback(err);
/******/ }
/******/ request.onreadystatechange = function() {
/******/ if(request.readyState !== 4) return;
/******/ if(request.status === 0) {
/******/ // timeout
/******/ callback(new Error("Manifest request to " + requestPath + " timed out."));
/******/ } else if(request.status === 404) {
/******/ // no update available
/******/ callback();
/******/ } else if(request.status !== 200 && request.status !== 304) {
/******/ // other failure
/******/ callback(new Error("Manifest request to " + requestPath + " failed."));
/******/ } else {
/******/ // success
/******/ try {
/******/ var update = JSON.parse(request.responseText);
/******/ } catch(e) {
/******/ callback(e);
/******/ return;
/******/ }
/******/ callback(null, update);
/******/ }
/******/ };
/******/ }
/******/
/******/
/******/ var hotApplyOnUpdate = true;
/******/ var hotCurrentHash = "fdcf32c155e4d7bb1399"; // eslint-disable-line no-unused-vars
/******/ var hotCurrentModuleData = {};
/******/ var hotCurrentParents = []; // eslint-disable-line no-unused-vars
/******/
/******/ function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
/******/ var me = installedModules[moduleId];
/******/ if(!me) return __webpack_require__;
/******/ var fn = function(request) {
/******/ if(me.hot.active) {
/******/ if(installedModules[request]) {
/******/ if(installedModules[request].parents.indexOf(moduleId) < 0)
/******/ installedModules[request].parents.push(moduleId);
/******/ if(me.children.indexOf(request) < 0)
/******/ me.children.push(request);
/******/ } else hotCurrentParents = [moduleId];
/******/ } else {
/******/ console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId);
/******/ hotCurrentParents = [];
/******/ }
/******/ return __webpack_require__(request);
/******/ };
/******/ for(var name in __webpack_require__) {
/******/ if(Object.prototype.hasOwnProperty.call(__webpack_require__, name)) {
/******/ fn[name] = __webpack_require__[name];
/******/ }
/******/ }
/******/ fn.e = function(chunkId, callback) {
/******/ if(hotStatus === "ready")
/******/ hotSetStatus("prepare");
/******/ hotChunksLoading++;
/******/ __webpack_require__.e(chunkId, function() {
/******/ try {
/******/ callback.call(null, fn);
/******/ } finally {
/******/ finishChunkLoading();
/******/ }
/******/
/******/ function finishChunkLoading() {
/******/ hotChunksLoading--;
/******/ if(hotStatus === "prepare") {
/******/ if(!hotWaitingFilesMap[chunkId]) {
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/ }
/******/ });
/******/ };
/******/ return fn;
/******/ }
/******/
/******/ function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars
/******/ var hot = {
/******/ // private stuff
/******/ _acceptedDependencies: {},
/******/ _declinedDependencies: {},
/******/ _selfAccepted: false,
/******/ _selfDeclined: false,
/******/ _disposeHandlers: [],
/******/
/******/ // Module API
/******/ active: true,
/******/ accept: function(dep, callback) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfAccepted = true;
/******/ else if(typeof dep === "function")
/******/ hot._selfAccepted = dep;
/******/ else if(typeof dep === "object")
/******/ for(var i = 0; i < dep.length; i++)
/******/ hot._acceptedDependencies[dep[i]] = callback;
/******/ else
/******/ hot._acceptedDependencies[dep] = callback;
/******/ },
/******/ decline: function(dep) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfDeclined = true;
/******/ else if(typeof dep === "number")
/******/ hot._declinedDependencies[dep] = true;
/******/ else
/******/ for(var i = 0; i < dep.length; i++)
/******/ hot._declinedDependencies[dep[i]] = true;
/******/ },
/******/ dispose: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ addDisposeHandler: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ removeDisposeHandler: function(callback) {
/******/ var idx = hot._disposeHandlers.indexOf(callback);
/******/ if(idx >= 0) hot._disposeHandlers.splice(idx, 1);
/******/ },
/******/
/******/ // Management API
/******/ check: hotCheck,
/******/ apply: hotApply,
/******/ status: function(l) {
/******/ if(!l) return hotStatus;
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ addStatusHandler: function(l) {
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ removeStatusHandler: function(l) {
/******/ var idx = hotStatusHandlers.indexOf(l);
/******/ if(idx >= 0) hotStatusHandlers.splice(idx, 1);
/******/ },
/******/
/******/ //inherit from previous dispose call
/******/ data: hotCurrentModuleData[moduleId]
/******/ };
/******/ return hot;
/******/ }
/******/
/******/ var hotStatusHandlers = [];
/******/ var hotStatus = "idle";
/******/
/******/ function hotSetStatus(newStatus) {
/******/ hotStatus = newStatus;
/******/ for(var i = 0; i < hotStatusHandlers.length; i++)
/******/ hotStatusHandlers[i].call(null, newStatus);
/******/ }
/******/
/******/ // while downloading
/******/ var hotWaitingFiles = 0;
/******/ var hotChunksLoading = 0;
/******/ var hotWaitingFilesMap = {};
/******/ var hotRequestedFilesMap = {};
/******/ var hotAvailibleFilesMap = {};
/******/ var hotCallback;
/******/
/******/ // The update info
/******/ var hotUpdate, hotUpdateNewHash;
/******/
/******/ function toModuleId(id) {
/******/ var isNumber = (+id) + "" === id;
/******/ return isNumber ? +id : id;
/******/ }
/******/
/******/ function hotCheck(apply, callback) {
/******/ if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status");
/******/ if(typeof apply === "function") {
/******/ hotApplyOnUpdate = false;
/******/ callback = apply;
/******/ } else {
/******/ hotApplyOnUpdate = apply;
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ }
/******/ hotSetStatus("check");
/******/ hotDownloadManifest(function(err, update) {
/******/ if(err) return callback(err);
/******/ if(!update) {
/******/ hotSetStatus("idle");
/******/ callback(null, null);
/******/ return;
/******/ }
/******/
/******/ hotRequestedFilesMap = {};
/******/ hotAvailibleFilesMap = {};
/******/ hotWaitingFilesMap = {};
/******/ for(var i = 0; i < update.c.length; i++)
/******/ hotAvailibleFilesMap[update.c[i]] = true;
/******/ hotUpdateNewHash = update.h;
/******/
/******/ hotSetStatus("prepare");
/******/ hotCallback = callback;
/******/ hotUpdate = {};
/******/ var chunkId = 0;
/******/ { // eslint-disable-line no-lone-blocks
/******/ /*globals chunkId */
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ });
/******/ }
/******/
/******/ function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars
/******/ if(!hotAvailibleFilesMap[chunkId] || !hotRequestedFilesMap[chunkId])
/******/ return;
/******/ hotRequestedFilesMap[chunkId] = false;
/******/ for(var moduleId in moreModules) {
/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
/******/ hotUpdate[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(--hotWaitingFiles === 0 && hotChunksLoading === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/
/******/ function hotEnsureUpdateChunk(chunkId) {
/******/ if(!hotAvailibleFilesMap[chunkId]) {
/******/ hotWaitingFilesMap[chunkId] = true;
/******/ } else {
/******/ hotRequestedFilesMap[chunkId] = true;
/******/ hotWaitingFiles++;
/******/ hotDownloadUpdateChunk(chunkId);
/******/ }
/******/ }
/******/
/******/ function hotUpdateDownloaded() {
/******/ hotSetStatus("ready");
/******/ var callback = hotCallback;
/******/ hotCallback = null;
/******/ if(!callback) return;
/******/ if(hotApplyOnUpdate) {
/******/ hotApply(hotApplyOnUpdate, callback);
/******/ } else {
/******/ var outdatedModules = [];
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ outdatedModules.push(toModuleId(id));
/******/ }
/******/ }
/******/ callback(null, outdatedModules);
/******/ }
/******/ }
/******/
/******/ function hotApply(options, callback) {
/******/ if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status");
/******/ if(typeof options === "function") {
/******/ callback = options;
/******/ options = {};
/******/ } else if(options && typeof options === "object") {
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ } else {
/******/ options = {};
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ }
/******/
/******/ function getAffectedStuff(module) {
/******/ var outdatedModules = [module];
/******/ var outdatedDependencies = {};
/******/
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module || module.hot._selfAccepted)
/******/ continue;
/******/ if(module.hot._selfDeclined) {
/******/ return new Error("Aborted because of self decline: " + moduleId);
/******/ }
/******/ if(moduleId === 0) {
/******/ return;
/******/ }
/******/ for(var i = 0; i < module.parents.length; i++) {
/******/ var parentId = module.parents[i];
/******/ var parent = installedModules[parentId];
/******/ if(parent.hot._declinedDependencies[moduleId]) {
/******/ return new Error("Aborted because of declined dependency: " + moduleId + " in " + parentId);
/******/ }
/******/ if(outdatedModules.indexOf(parentId) >= 0) continue;
/******/ if(parent.hot._acceptedDependencies[moduleId]) {
/******/ if(!outdatedDependencies[parentId])
/******/ outdatedDependencies[parentId] = [];
/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
/******/ continue;
/******/ }
/******/ delete outdatedDependencies[parentId];
/******/ outdatedModules.push(parentId);
/******/ queue.push(parentId);
/******/ }
/******/ }
/******/
/******/ return [outdatedModules, outdatedDependencies];
/******/ }
/******/
/******/ function addAllToSet(a, b) {
/******/ for(var i = 0; i < b.length; i++) {
/******/ var item = b[i];
/******/ if(a.indexOf(item) < 0)
/******/ a.push(item);
/******/ }
/******/ }
/******/
/******/ // at begin all updates modules are outdated
/******/ // the "outdated" status can propagate to parents if they don't accept the children
/******/ var outdatedDependencies = {};
/******/ var outdatedModules = [];
/******/ var appliedUpdate = {};
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ var moduleId = toModuleId(id);
/******/ var result = getAffectedStuff(moduleId);
/******/ if(!result) {
/******/ if(options.ignoreUnaccepted)
/******/ continue;
/******/ hotSetStatus("abort");
/******/ return callback(new Error("Aborted because " + moduleId + " is not accepted"));
/******/ }
/******/ if(result instanceof Error) {
/******/ hotSetStatus("abort");
/******/ return callback(result);
/******/ }
/******/ appliedUpdate[moduleId] = hotUpdate[moduleId];
/******/ addAllToSet(outdatedModules, result[0]);
/******/ for(var moduleId in result[1]) {
/******/ if(Object.prototype.hasOwnProperty.call(result[1], moduleId)) {
/******/ if(!outdatedDependencies[moduleId])
/******/ outdatedDependencies[moduleId] = [];
/******/ addAllToSet(outdatedDependencies[moduleId], result[1][moduleId]);
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Store self accepted outdated modules to require them later by the module system
/******/ var outdatedSelfAcceptedModules = [];
/******/ for(var i = 0; i < outdatedModules.length; i++) {
/******/ var moduleId = outdatedModules[i];
/******/ if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted)
/******/ outdatedSelfAcceptedModules.push({
/******/ module: moduleId,
/******/ errorHandler: installedModules[moduleId].hot._selfAccepted
/******/ });
/******/ }
/******/
/******/ // Now in "dispose" phase
/******/ hotSetStatus("dispose");
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module) continue;
/******/
/******/ var data = {};
/******/
/******/ // Call dispose handlers
/******/ var disposeHandlers = module.hot._disposeHandlers;
/******/ for(var j = 0; j < disposeHandlers.length; j++) {
/******/ var cb = disposeHandlers[j];
/******/ cb(data);
/******/ }
/******/ hotCurrentModuleData[moduleId] = data;
/******/
/******/ // disable module (this disables requires from this module)
/******/ module.hot.active = false;
/******/
/******/ // remove module from cache
/******/ delete installedModules[moduleId];
/******/
/******/ // remove "parents" references from all children
/******/ for(var j = 0; j < module.children.length; j++) {
/******/ var child = installedModules[module.children[j]];
/******/ if(!child) continue;
/******/ var idx = child.parents.indexOf(moduleId);
/******/ if(idx >= 0) {
/******/ child.parents.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // remove outdated dependency from module children
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ for(var j = 0; j < moduleOutdatedDependencies.length; j++) {
/******/ var dependency = moduleOutdatedDependencies[j];
/******/ var idx = module.children.indexOf(dependency);
/******/ if(idx >= 0) module.children.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // Not in "apply" phase
/******/ hotSetStatus("apply");
/******/
/******/ hotCurrentHash = hotUpdateNewHash;
/******/
/******/ // insert new code
/******/ for(var moduleId in appliedUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
/******/ modules[moduleId] = appliedUpdate[moduleId];
/******/ }
/******/ }
/******/
/******/ // call accept handlers
/******/ var error = null;
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ var callbacks = [];
/******/ for(var i = 0; i < moduleOutdatedDependencies.length; i++) {
/******/ var dependency = moduleOutdatedDependencies[i];
/******/ var cb = module.hot._acceptedDependencies[dependency];
/******/ if(callbacks.indexOf(cb) >= 0) continue;
/******/ callbacks.push(cb);
/******/ }
/******/ for(var i = 0; i < callbacks.length; i++) {
/******/ var cb = callbacks[i];
/******/ try {
/******/ cb(outdatedDependencies);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Load self accepted modules
/******/ for(var i = 0; i < outdatedSelfAcceptedModules.length; i++) {
/******/ var item = outdatedSelfAcceptedModules[i];
/******/ var moduleId = item.module;
/******/ hotCurrentParents = [moduleId];
/******/ try {
/******/ __webpack_require__(moduleId);
/******/ } catch(err) {
/******/ if(typeof item.errorHandler === "function") {
/******/ try {
/******/ item.errorHandler(err);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ } else if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/
/******/ // handle errors in accept handlers and self accepted module load
/******/ if(error) {
/******/ hotSetStatus("fail");
/******/ return callback(error);
/******/ }
/******/
/******/ hotSetStatus("idle");
/******/ callback(null, outdatedModules);
/******/ }
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false,
/******/ hot: hotCreateModule(moduleId),
/******/ parents: hotCurrentParents,
/******/ children: []
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // __webpack_hash__
/******/ __webpack_require__.h = function() { return hotCurrentHash; };
/******/ // Load entry module and return exports
/******/ return hotCreateRequire(0)(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(1);
module.exports = __webpack_require__(3);
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
/*globals window __webpack_hash__ */
if(true) {
var lastData;
var upToDate = function upToDate() {
return lastData.indexOf(__webpack_require__.h()) >= 0;
};
var check = function check() {
module.hot.check(true, function(err, updatedModules) {
if(err) {
if(module.hot.status() in {
abort: 1,
fail: 1
}) {
console.warn("[HMR] Cannot apply update. Need to do a full reload!");
console.warn("[HMR] " + err.stack || err.message);
window.location.reload();
} else {
console.warn("[HMR] Update failed: " + err.stack || err.message);
}
return;
}
if(!updatedModules) {
console.warn("[HMR] Cannot find update. Need to do a full reload!");
console.warn("[HMR] (Probably because of restarting the webpack-dev-server)");
window.location.reload();
return;
}
if(!upToDate()) {
check();
}
__webpack_require__(2)(updatedModules, updatedModules);
if(upToDate()) {
console.log("[HMR] App is up to date.");
}
});
};
var addEventListener = window.addEventListener ? function(eventName, listener) {
window.addEventListener(eventName, listener, false);
} : function(eventName, listener) {
window.attachEvent("on" + eventName, listener);
};
addEventListener("message", function(event) {
if(typeof event.data === "string" && event.data.indexOf("webpackHotUpdate") === 0) {
lastData = event.data;
if(!upToDate() && module.hot.status() === "idle") {
console.log("[HMR] Checking for updates on the server...");
check();
}
}
});
console.log("[HMR] Waiting for update signal from WDS...");
} else {
throw new Error("[HMR] Hot Module Replacement is disabled.");
}
/***/ },
/* 2 */
/***/ function(module, exports) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
module.exports = function(updatedModules, renewedModules) {
var unacceptedModules = updatedModules.filter(function(moduleId) {
return renewedModules && renewedModules.indexOf(moduleId) < 0;
});
if(unacceptedModules.length > 0) {
console.warn("[HMR] The following modules couldn't be hot updated: (They would need a full reload!)");
unacceptedModules.forEach(function(moduleId) {
console.warn("[HMR] - " + moduleId);
});
}
if(!renewedModules || renewedModules.length === 0) {
console.log("[HMR] Nothing hot updated.");
} else {
console.log("[HMR] Updated modules:");
renewedModules.forEach(function(moduleId) {
console.log("[HMR] - " + moduleId);
});
}
};
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
/*jshint browser:true */
'use strict';
__webpack_require__(4)();
var appModule = __webpack_require__(11);
angular.element(document).ready(function () {
angular.bootstrap(document, [appModule.name], {
//strictDi: true
});
});
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = function () {
/* Styles */
__webpack_require__(5);
/* JS */
__webpack_require__(9);
};
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(6);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(6, function() {
var newContent = __webpack_require__(6);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "body {\n background-color: red; }\n", ""]);
// exports
/***/ },
/* 7 */
/***/ function(module, exports) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
// css base code, injected by the css-loader
module.exports = function() {
var list = [];
// return the list of modules as css string
list.toString = function toString() {
var result = [];
for(var i = 0; i < this.length; i++) {
var item = this[i];
if(item[2]) {
result.push("@media " + item[2] + "{" + item[1] + "}");
} else {
result.push(item[1]);
}
}
return result.join("");
};
// import a list of modules into the list
list.i = function(modules, mediaQuery) {
if(typeof modules === "string")
modules = [[null, modules, ""]];
var alreadyImportedModules = {};
for(var i = 0; i < this.length; i++) {
var id = this[i][0];
if(typeof id === "number")
alreadyImportedModules[id] = true;
}
for(i = 0; i < modules.length; i++) {
var item = modules[i];
// skip already imported module
// this implementation is not 100% perfect for weird media query combinations
// when a module is imported multiple times with different media queries.
// I hope this will never occur (Hey this way we have smaller bundles)
if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
if(mediaQuery && !item[2]) {
item[2] = mediaQuery;
} else if(mediaQuery) {
item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
}
list.push(item);
}
}
};
return list;
};
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var stylesInDom = {},
memoize = function(fn) {
var memo;
return function () {
if (typeof memo === "undefined") memo = fn.apply(this, arguments);
return memo;
};
},
isOldIE = memoize(function() {
return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
}),
getHeadElement = memoize(function () {
return document.head || document.getElementsByTagName("head")[0];
}),
singletonElement = null,
singletonCounter = 0,
styleElementsInsertedAtTop = [];
module.exports = function(list, options) {
if(false) {
if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
}
options = options || {};
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
// tags it will allow on a page
if (typeof options.singleton === "undefined") options.singleton = isOldIE();
// By default, add <style> tags to the bottom of <head>.
if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
var styles = listToStyles(list);
addStylesToDom(styles, options);
return function update(newList) {
var mayRemove = [];
for(var i = 0; i < styles.length; i++) {
var item = styles[i];
var domStyle = stylesInDom[item.id];
domStyle.refs--;
mayRemove.push(domStyle);
}
if(newList) {
var newStyles = listToStyles(newList);
addStylesToDom(newStyles, options);
}
for(var i = 0; i < mayRemove.length; i++) {
var domStyle = mayRemove[i];
if(domStyle.refs === 0) {
for(var j = 0; j < domStyle.parts.length; j++)
domStyle.parts[j]();
delete stylesInDom[domStyle.id];
}
}
};
}
function addStylesToDom(styles, options) {
for(var i = 0; i < styles.length; i++) {
var item = styles[i];
var domStyle = stylesInDom[item.id];
if(domStyle) {
domStyle.refs++;
for(var j = 0; j < domStyle.parts.length; j++) {
domStyle.parts[j](item.parts[j]);
}
for(; j < item.parts.length; j++) {
domStyle.parts.push(addStyle(item.parts[j], options));
}
} else {
var parts = [];
for(var j = 0; j < item.parts.length; j++) {
parts.push(addStyle(item.parts[j], options));
}
stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
}
}
}
function listToStyles(list) {
var styles = [];
var newStyles = {};
for(var i = 0; i < list.length; i++) {
var item = list[i];
var id = item[0];
var css = item[1];
var media = item[2];
var sourceMap = item[3];
var part = {css: css, media: media, sourceMap: sourceMap};
if(!newStyles[id])
styles.push(newStyles[id] = {id: id, parts: [part]});
else
newStyles[id].parts.push(part);
}
return styles;
}
function insertStyleElement(options, styleElement) {
var head = getHeadElement();
var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
if (options.insertAt === "top") {
if(!lastStyleElementInsertedAtTop) {
head.insertBefore(styleElement, head.firstChild);
} else if(lastStyleElementInsertedAtTop.nextSibling) {
head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
} else {
head.appendChild(styleElement);
}
styleElementsInsertedAtTop.push(styleElement);
} else if (options.insertAt === "bottom") {
head.appendChild(styleElement);
} else {
throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
}
}
function removeStyleElement(styleElement) {
styleElement.parentNode.removeChild(styleElement);
var idx = styleElementsInsertedAtTop.indexOf(styleElement);
if(idx >= 0) {
styleElementsInsertedAtTop.splice(idx, 1);
}
}
function createStyleElement(options) {
var styleElement = document.createElement("style");
styleElement.type = "text/css";
insertStyleElement(options, styleElement);
return styleElement;
}
function createLinkElement(options) {
var linkElement = document.createElement("link");
linkElement.rel = "stylesheet";
insertStyleElement(options, linkElement);
return linkElement;
}
function addStyle(obj, options) {
var styleElement, update, remove;
if (options.singleton) {
var styleIndex = singletonCounter++;
styleElement = singletonElement || (singletonElement = createStyleElement(options));
update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
} else if(obj.sourceMap &&
typeof URL === "function" &&
typeof URL.createObjectURL === "function" &&
typeof URL.revokeObjectURL === "function" &&
typeof Blob === "function" &&
typeof btoa === "function") {
styleElement = createLinkElement(options);
update = updateLink.bind(null, styleElement);
remove = function() {
removeStyleElement(styleElement);
if(styleElement.href)
URL.revokeObjectURL(styleElement.href);
};
} else {
styleElement = createStyleElement(options);
update = applyToTag.bind(null, styleElement);
remove = function() {
removeStyleElement(styleElement);
};
}
update(obj);
return function updateStyle(newObj) {
if(newObj) {
if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
return;
update(obj = newObj);
} else {
remove();
}
};
}
var replaceText = (function () {
var textStore = [];
return function (index, replacement) {
textStore[index] = replacement;
return textStore.filter(Boolean).join('\n');
};
})();
function applyToSingletonTag(styleElement, index, remove, obj) {
var css = remove ? "" : obj.css;
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = replaceText(index, css);
} else {
var cssNode = document.createTextNode(css);
var childNodes = styleElement.childNodes;
if (childNodes[index]) styleElement.removeChild(childNodes[index]);
if (childNodes.length) {
styleElement.insertBefore(cssNode, childNodes[index]);
} else {
styleElement.appendChild(cssNode);
}
}
}
function applyToTag(styleElement, obj) {
var css = obj.css;
var media = obj.media;
var sourceMap = obj.sourceMap;
if(media) {
styleElement.setAttribute("media", media)
}
if(styleElement.styleSheet) {
styleElement.styleSheet.cssText = css;
} else {
while(styleElement.firstChild) {
styleElement.removeChild(styleElement.firstChild);
}
styleElement.appendChild(document.createTextNode(css));
}
}
function updateLink(linkElement, obj) {
var css = obj.css;
var media = obj.media;
var sourceMap = obj.sourceMap;
if(sourceMap) {
// http://stackoverflow.com/a/26603875
css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
}
var blob = new Blob([css], { type: "text/css" });
var oldSrc = linkElement.href;
linkElement.href = URL.createObjectURL(blob);
if(oldSrc)
URL.revokeObjectURL(oldSrc);
}
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(10);
module.exports = angular;
/***/ },
/* 10 */
/***/ function(module, exports) {
/**
* @license AngularJS v1.4.8
* (c) 2010-2015 Google, Inc. http://angularjs.org
* License: MIT
*/
(function(window, document, undefined) {'use strict';
/**
* @description
*
* This object provides a utility for producing rich Error messages within
* Angular. It can be called as follows:
*
* var exampleMinErr = minErr('example');
* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
*
* The above creates an instance of minErr in the example namespace. The
* resulting error will have a namespaced error code of example.one. The
* resulting error will replace {0} with the value of foo, and {1} with the
* value of bar. The object is not restricted in the number of arguments it can
* take.
*
* If fewer arguments are specified than necessary for interpolation, the extra
* interpolation markers will be preserved in the final string.
*
* Since data will be parsed statically during a build step, some restrictions
* are applied with respect to how minErr instances are created and called.
* Instances should have names of the form namespaceMinErr for a minErr created
* using minErr('namespace') . Error codes, namespaces and template strings
* should all be static strings, not variables or general expressions.
*
* @param {string} module The namespace to use for the new minErr instance.
* @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
* error from returned function, for cases when a particular type of error is useful.
* @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
*/
function minErr(module, ErrorConstructor) {
ErrorConstructor = ErrorConstructor || Error;
return function() {
var SKIP_INDEXES = 2;
var templateArgs = arguments,
code = templateArgs[0],
message = '[' + (module ? module + ':' : '') + code + '] ',
template = templateArgs[1],
paramPrefix, i;
message += template.replace(/\{\d+\}/g, function(match) {
var index = +match.slice(1, -1),
shiftedIndex = index + SKIP_INDEXES;
if (shiftedIndex < templateArgs.length) {
return toDebugString(templateArgs[shiftedIndex]);
}
return match;
});
message += '\nhttp://errors.angularjs.org/1.4.8/' +
(module ? module + '/' : '') + code;
for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
encodeURIComponent(toDebugString(templateArgs[i]));
}
return new ErrorConstructor(message);
};
}
/* We need to tell jshint what variables are being exported */
/* global angular: true,
msie: true,
jqLite: true,
jQuery: true,
slice: true,
splice: true,
push: true,
toString: true,
ngMinErr: true,
angularModule: true,
uid: true,
REGEX_STRING_REGEXP: true,
VALIDITY_STATE_PROPERTY: true,
lowercase: true,
uppercase: true,
manualLowercase: true,
manualUppercase: true,
nodeName_: true,
isArrayLike: true,
forEach: true,
forEachSorted: true,
reverseParams: true,
nextUid: true,
setHashKey: true,
extend: true,
toInt: true,
inherit: true,
merge: true,
noop: true,
identity: true,
valueFn: true,
isUndefined: true,
isDefined: true,
isObject: true,
isBlankObject: true,
isString: true,
isNumber: true,
isDate: true,
isArray: true,
isFunction: true,
isRegExp: true,
isWindow: true,
isScope: true,
isFile: true,
isFormData: true,
isBlob: true,
isBoolean: true,
isPromiseLike: true,
trim: true,
escapeForRegexp: true,
isElement: true,
makeMap: true,
includes: true,
arrayRemove: true,
copy: true,
shallowCopy: true,
equals: true,
csp: true,
jq: true,
concat: true,
sliceArgs: true,
bind: true,
toJsonReplacer: true,
toJson: true,
fromJson: true,
convertTimezoneToLocal: true,
timezoneToOffset: true,
startingTag: true,
tryDecodeURIComponent: true,
parseKeyValue: true,
toKeyValue: true,
encodeUriSegment: true,
encodeUriQuery: true,
angularInit: true,
bootstrap: true,
getTestability: true,
snake_case: true,
bindJQuery: true,
assertArg: true,
assertArgFn: true,
assertNotHasOwnProperty: true,
getter: true,
getBlockNodes: true,
hasOwnProperty: true,
createMap: true,
NODE_TYPE_ELEMENT: true,
NODE_TYPE_ATTRIBUTE: true,
NODE_TYPE_TEXT: true,
NODE_TYPE_COMMENT: true,
NODE_TYPE_DOCUMENT: true,
NODE_TYPE_DOCUMENT_FRAGMENT: true,
*/
////////////////////////////////////
/**
* @ngdoc module
* @name ng
* @module ng
* @description
*
* # ng (core module)
* The ng module is loaded by default when an AngularJS application is started. The module itself
* contains the essential components for an AngularJS application to function. The table below
* lists a high level breakdown of each of the services/factories, filters, directives and testing
* components available within this core module.
*
* <div doc-module-components="ng"></div>
*/
var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
// The name of a form control's ValidityState property.
// This is used so that it's possible for internal tests to create mock ValidityStates.
var VALIDITY_STATE_PROPERTY = 'validity';
/**
* @ngdoc function
* @name angular.lowercase
* @module ng
* @kind function
*
* @description Converts the specified string to lowercase.
* @param {string} string String to be converted to lowercase.
* @returns {string} Lowercased string.
*/
var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
var hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* @ngdoc function
* @name angular.uppercase
* @module ng
* @kind function
*
* @description Converts the specified string to uppercase.
* @param {string} string String to be converted to uppercase.
* @returns {string} Uppercased string.
*/
var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
var manualLowercase = function(s) {
/* jshint bitwise: false */
return isString(s)
? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})
: s;
};
var manualUppercase = function(s) {
/* jshint bitwise: false */
return isString(s)
? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
: s;
};
// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
// with correct but slower alternatives.
if ('i' !== 'I'.toLowerCase()) {
lowercase = manualLowercase;
uppercase = manualUppercase;
}
var
msie, // holds major version number for IE, or NaN if UA is not IE.
jqLite, // delay binding since jQuery could be loaded after us.
jQuery, // delay binding
slice = [].slice,
splice = [].splice,
push = [].push,
toString = Object.prototype.toString,
getPrototypeOf = Object.getPrototypeOf,
ngMinErr = minErr('ng'),
/** @name angular */
angular = window.angular || (window.angular = {}),
angularModule,
uid = 0;
/**
* documentMode is an IE-only property
* http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
*/
msie = document.documentMode;
/**
* @private
* @param {*} obj
* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
* String ...)
*/
function isArrayLike(obj) {
// `null`, `undefined` and `window` are not array-like
if (obj == null || isWindow(obj)) return false;
// arrays, strings and jQuery/jqLite objects are array like
// * jqLite is either the jQuery or jqLite constructor function
// * we have to check the existance of jqLite first as this method is called
// via the forEach method when constructing the jqLite object in the first place
if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
// Support: iOS 8.2 (not reproducible in simulator)
// "length" in obj used to prevent JIT error (gh-11508)
var length = "length" in Object(obj) && obj.length;
// NodeList objects (with `item` method) and
// other objects with suitable length characteristics are array-like
return isNumber(length) &&
(length >= 0 && (length - 1) in obj || typeof obj.item == 'function');
}
/**
* @ngdoc function
* @name angular.forEach
* @module ng
* @kind function
*
* @description
* Invokes the `iterator` function once for each item in `obj` collection, which can be either an
* object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value`
* is the value of an object property or an array element, `key` is the object property key or
* array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
*
* It is worth noting that `.forEach` does not iterate over inherited properties because it filters
* using the `hasOwnProperty` method.
*
* Unlike ES262's
* [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
* Providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
* return the value provided.
*
```js
var values = {name: 'misko', gender: 'male'};
var log = [];
angular.forEach(values, function(value, key) {
this.push(key + ': ' + value);
}, log);
expect(log).toEqual(['name: misko', 'gender: male']);
```
*
* @param {Object|Array} obj Object to iterate over.
* @param {Function} iterator Iterator function.
* @param {Object=} context Object to become context (`this`) for the iterator function.
* @returns {Object|Array} Reference to `obj`.
*/
function forEach(obj, iterator, context) {
var key, length;
if (obj) {
if (isFunction(obj)) {
for (key in obj) {
// Need to check if hasOwnProperty exists,
// as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {
iterator.call(context, obj[key], key, obj);
}
}
} else if (isArray(obj) || isArrayLike(obj)) {
var isPrimitive = typeof obj !== 'object';
for (key = 0, length = obj.length; key < length; key++) {
if (isPrimitive || key in obj) {
iterator.call(context, obj[key], key, obj);
}
}
} else if (obj.forEach && obj.forEach !== forEach) {
obj.forEach(iterator, context, obj);
} else if (isBlankObject(obj)) {
// createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
for (key in obj) {
iterator.call(context, obj[key], key, obj);
}
} else if (typeof obj.hasOwnProperty === 'function') {
// Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
for (key in obj) {
if (obj.hasOwnProperty(key)) {
iterator.call(context, obj[key], key, obj);
}
}
} else {
// Slow path for objects which do not have a method `hasOwnProperty`
for (key in obj) {
if (hasOwnProperty.call(obj, key)) {
iterator.call(context, obj[key], key, obj);
}
}
}
}
return obj;
}
function forEachSorted(obj, iterator, context) {
var keys = Object.keys(obj).sort();
for (var i = 0; i < keys.length; i++) {
iterator.call(context, obj[keys[i]], keys[i]);
}
return keys;
}
/**
* when using forEach the params are value, key, but it is often useful to have key, value.
* @param {function(string, *)} iteratorFn
* @returns {function(*, string)}
*/
function reverseParams(iteratorFn) {
return function(value, key) { iteratorFn(key, value); };
}
/**
* A consistent way of creating unique IDs in angular.
*
* Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before
* we hit number precision issues in JavaScript.
*
* Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M
*
* @returns {number} an unique alpha-numeric string
*/
function nextUid() {
return ++uid;
}
/**
* Set or clear the hashkey for an object.
* @param obj object
* @param h the hashkey (!truthy to delete the hashkey)
*/
function setHashKey(obj, h) {
if (h) {
obj.$$hashKey = h;
} else {
delete obj.$$hashKey;
}
}
function baseExtend(dst, objs, deep) {
var h = dst.$$hashKey;
for (var i = 0, ii = objs.length; i < ii; ++i) {
var obj = objs[i];
if (!isObject(obj) && !isFunction(obj)) continue;
var keys = Object.keys(obj);
for (var j = 0, jj = keys.length; j < jj; j++) {
var key = keys[j];
var src = obj[key];
if (deep && isObject(src)) {
if (isDate(src)) {
dst[key] = new Date(src.valueOf());
} else if (isRegExp(src)) {
dst[key] = new RegExp(src);
} else if (src.nodeName) {
dst[key] = src.cloneNode(true);
} else if (isElement(src)) {
dst[key] = src.clone();
} else {
if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
baseExtend(dst[key], [src], true);
}
} else {
dst[key] = src;
}
}
}
setHashKey(dst, h);
return dst;
}
/**
* @ngdoc function
* @name angular.extend
* @module ng
* @kind function
*
* @description
* Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
* by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
*
* **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
* {@link angular.merge} for this.
*
* @param {Object} dst Destination object.
* @param {...Object} src Source object(s).
* @returns {Object} Reference to `dst`.
*/
function extend(dst) {
return baseExtend(dst, slice.call(arguments, 1), false);
}
/**
* @ngdoc function
* @name angular.merge
* @module ng
* @kind function
*
* @description
* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
* by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`.
*
* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
* objects, performing a deep copy.
*
* @param {Object} dst Destination object.
* @param {...Object} src Source object(s).
* @returns {Object} Reference to `dst`.
*/
function merge(dst) {
return baseExtend(dst, slice.call(arguments, 1), true);
}
function toInt(str) {
return parseInt(str, 10);
}
function inherit(parent, extra) {
return extend(Object.create(parent), extra);
}
/**
* @ngdoc function
* @name angular.noop
* @module ng
* @kind function
*
* @description
* A function that performs no operations. This function can be useful when writing code in the
* functional style.
```js
function foo(callback) {
var result = calculateResult();
(callback || angular.noop)(result);
}
```
*/
function noop() {}
noop.$inject = [];
/**
* @ngdoc function
* @name angular.identity
* @module ng
* @kind function
*
* @description
* A function that returns its first argument. This function is useful when writing code in the
* functional style.
*
```js
function transformer(transformationFn, value) {
return (transformationFn || angular.identity)(value);
};
```
* @param {*} value to be returned.
* @returns {*} the value passed in.
*/
function identity($) {return $;}
identity.$inject = [];
function valueFn(value) {return function() {return value;};}
function hasCustomToString(obj) {
return isFunction(obj.toString) && obj.toString !== toString;
}
/**
* @ngdoc function
* @name angular.isUndefined
* @module ng
* @kind function
*
* @description
* Determines if a reference is undefined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is undefined.
*/
function isUndefined(value) {return typeof value === 'undefined';}
/**
* @ngdoc function
* @name angular.isDefined
* @module ng
* @kind function
*
* @description
* Determines if a reference is defined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is defined.
*/
function isDefined(value) {return typeof value !== 'undefined';}
/**
* @ngdoc function
* @name angular.isObject
* @module ng
* @kind function
*
* @description
* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
* considered to be objects. Note that JavaScript arrays are objects.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Object` but not `null`.
*/
function isObject(value) {
// http://jsperf.com/isobject4
return value !== null && typeof value === 'object';
}
/**
* Determine if a value is an object with a null prototype
*
* @returns {boolean} True if `value` is an `Object` with a null prototype
*/
function isBlankObject(value) {
return value !== null && typeof value === 'object' && !getPrototypeOf(value);
}
/**
* @ngdoc function
* @name angular.isString
* @module ng
* @kind function
*
* @description
* Determines if a reference is a `String`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `String`.
*/
function isString(value) {return typeof value === 'string';}
/**
* @ngdoc function
* @name angular.isNumber
* @module ng
* @kind function
*
* @description
* Determines if a reference is a `Number`.
*
* This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`.
*
* If you wish to exclude these then you can use the native
* [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
* method.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Number`.
*/
function isNumber(value) {return typeof value === 'number';}
/**
* @ngdoc function
* @name angular.isDate
* @module ng
* @kind function
*
* @description
* Determines if a value is a date.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Date`.
*/
function isDate(value) {
return toString.call(value) === '[object Date]';
}
/**
* @ngdoc function
* @name angular.isArray
* @module ng
* @kind function
*
* @description
* Determines if a reference is an `Array`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Array`.
*/
var isArray = Array.isArray;
/**
* @ngdoc function
* @name angular.isFunction
* @module ng
* @kind function
*
* @description
* Determines if a reference is a `Function`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Function`.
*/
function isFunction(value) {return typeof value === 'function';}
/**
* Determines if a value is a regular expression object.
*
* @private
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `RegExp`.
*/
function isRegExp(value) {
return toString.call(value) === '[object RegExp]';
}
/**
* Checks if `obj` is a window object.
*
* @private
* @param {*} obj Object to check
* @returns {boolean} True if `obj` is a window obj.
*/
function isWindow(obj) {
return obj && obj.window === obj;
}
function isScope(obj) {
return obj && obj.$evalAsync && obj.$watch;
}
function isFile(obj) {
return toString.call(obj) === '[object File]';
}
function isFormData(obj) {
return toString.call(obj) === '[object FormData]';
}
function isBlob(obj) {
return toString.call(obj) === '[object Blob]';
}
function isBoolean(value) {
return typeof value === 'boolean';
}
function isPromiseLike(obj) {
return obj && isFunction(obj.then);
}
var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array\]$/;
function isTypedArray(value) {
return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
}
var trim = function(value) {
return isString(value) ? value.trim() : value;
};
// Copied from:
// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
// Prereq: s is a string.
var escapeForRegexp = function(s) {
return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
replace(/\x08/g, '\\x08');
};
/**
* @ngdoc function
* @name angular.isElement
* @module ng
* @kind function
*
* @description
* Determines if a reference is a DOM element (or wrapped jQuery element).
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
*/
function isElement(node) {
return !!(node &&
(node.nodeName // we are a direct element
|| (node.prop && node.attr && node.find))); // we have an on and find method part of jQuery API
}
/**
* @param str 'key1,key2,...'
* @returns {object} in the form of {key1:true, key2:true, ...}
*/
function makeMap(str) {
var obj = {}, items = str.split(","), i;
for (i = 0; i < items.length; i++) {
obj[items[i]] = true;
}
return obj;
}
function nodeName_(element) {
return lowercase(element.nodeName || (element[0] && element[0].nodeName));
}
function includes(array, obj) {
return Array.prototype.indexOf.call(array, obj) != -1;
}
function arrayRemove(array, value) {
var index = array.indexOf(value);
if (index >= 0) {
array.splice(index, 1);
}
return index;
}
/**
* @ngdoc function
* @name angular.copy
* @module ng
* @kind function
*
* @description
* Creates a deep copy of `source`, which should be an object or an array.
*
* * If no destination is supplied, a copy of the object or array is created.
* * If a destination is provided, all of its elements (for arrays) or properties (for objects)
* are deleted and then all elements/properties from the source are copied to it.
* * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
* * If `source` is identical to 'destination' an exception will be thrown.
*
* @param {*} source The source that will be used to make a copy.
* Can be any type, including primitives, `null`, and `undefined`.
* @param {(Object|Array)=} destination Destination into which the source is copied. If
* provided, must be of the same type as `source`.
* @returns {*} The copy or updated `destination`, if `destination` was specified.
*
* @example
<example module="copyExample">
<file name="index.html">
<div ng-controller="ExampleController">
<form novalidate class="simple-form">
Name: <input type="text" ng-model="user.name" /><br />
E-mail: <input type="email" ng-model="user.email" /><br />
Gender: <input type="radio" ng-model="user.gender" value="male" />male
<input type="radio" ng-model="user.gender" value="female" />female<br />
<button ng-click="reset()">RESET</button>
<button ng-click="update(user)">SAVE</button>
</form>
<pre>form = {{user | json}}</pre>
<pre>master = {{master | json}}</pre>
</div>
<script>
angular.module('copyExample', [])
.controller('ExampleController', ['$scope', function($scope) {
$scope.master= {};
$scope.update = function(user) {
// Example with 1 argument
$scope.master= angular.copy(user);
};
$scope.reset = function() {
// Example with 2 arguments
angular.copy($scope.master, $scope.user);
};
$scope.reset();
}]);
</script>
</file>
</example>
*/
function copy(source, destination) {
var stackSource = [];
var stackDest = [];
if (destination) {
if (isTypedArray(destination)) {
throw ngMinErr('cpta', "Can't copy! TypedArray destination cannot be mutated.");
}
if (source === destination) {
throw ngMinErr('cpi', "Can't copy! Source and destination are identical.");
}
// Empty the destination object
if (isArray(destination)) {
destination.length = 0;
} else {
forEach(destination, function(value, key) {
if (key !== '$$hashKey') {
delete destination[key];
}
});
}
stackSource.push(source);
stackDest.push(destination);
return copyRecurse(source, destination);
}
return copyElement(source);
function copyRecurse(source, destination) {
var h = destination.$$hashKey;
var result, key;
if (isArray(source)) {
for (var i = 0, ii = source.length; i < ii; i++) {
destination.push(copyElement(source[i]));
}
} else if (isBlankObject(source)) {
// createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
for (key in source) {
destination[key] = copyElement(source[key]);
}
} else if (source && typeof source.hasOwnProperty === 'function') {
// Slow path, which must rely on hasOwnProperty
for (key in source) {
if (source.hasOwnProperty(key)) {
destination[key] = copyElement(source[key]);
}
}
} else {
// Slowest path --- hasOwnProperty can't be called as a method
for (key in source) {
if (hasOwnProperty.call(source, key)) {
destination[key] = copyElement(source[key]);
}
}
}
setHashKey(destination, h);
return destination;
}
function copyElement(source) {
// Simple values
if (!isObject(source)) {
return source;
}
// Already copied values
var index = stackSource.indexOf(source);
if (index !== -1) {
return stackDest[index];
}
if (isWindow(source) || isScope(source)) {
throw ngMinErr('cpws',
"Can't copy! Making copies of Window or Scope instances is not supported.");
}
var needsRecurse = false;
var destination;
if (isArray(source)) {
destination = [];
needsRecurse = true;
} else if (isTypedArray(source)) {
destination = new source.constructor(source);
} else if (isDate(source)) {
destination = new Date(source.getTime());
} else if (isRegExp(source)) {
destination = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
destination.lastIndex = source.lastIndex;
} else if (isFunction(source.cloneNode)) {
destination = source.cloneNode(true);
} else {
destination = Object.create(getPrototypeOf(source));
needsRecurse = true;
}
stackSource.push(source);
stackDest.push(destination);
return needsRecurse
? copyRecurse(source, destination)
: destination;
}
}
/**
* 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;
}
/**
* @ngdoc function
* @name angular.equals
* @module ng
* @kind function
*
* @description
* Determines if two objects or two values are equivalent. Supports value types, regular
* expressions, arrays and objects.
*
* Two objects or values are considered equivalent if at least one of the following is true:
*
* * Both objects or values pass `===` comparison.
* * Both objects or values are of the same type and all of their properties are equal by
* comparing them with `angular.equals`.
* * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
* * Both values represent the same regular expression (In JavaScript,
* /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
* representation matches).
*
* During a property comparison, properties of `function` type and properties with names
* that begin with `$` are ignored.
*
* Scope and DOMWindow objects are being compared only by identify (`===`).
*
* @param {*} o1 Object or value to compare.
* @param {*} o2 Object or value to compare.
* @returns {boolean} True if arguments are equal.
*/
function equals(o1, o2) {
if (o1 === o2) return true;
if (o1 === null || o2 === null) return false;
if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
if (t1 == t2) {
if (t1 == 'object') {
if (isArray(o1)) {
if (!isArray(o2)) return false;
if ((length = o1.length) == o2.length) {
for (key = 0; key < length; key++) {
if (!equals(o1[key], o2[key])) return false;
}
return true;
}
} else if (isDate(o1)) {
if (!isDate(o2)) return false;
return equals(o1.getTime(), o2.getTime());
} else if (isRegExp(o1)) {
return isRegExp(o2) ? o1.toString() == o2.toString() : false;
} else {
if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
keySet = createMap();
for (key in o1) {
if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
if (!equals(o1[key], o2[key])) return false;
keySet[key] = true;
}
for (key in o2) {
if (!(key in keySet) &&
key.charAt(0) !== '$' &&
isDefined(o2[key]) &&
!isFunction(o2[key])) return false;
}
return true;
}
}
}
return false;
}
var csp = function() {
if (!isDefined(csp.rules)) {
var ngCspElement = (document.querySelector('[ng-csp]') ||
document.querySelector('[data-ng-csp]'));
if (ngCspElement) {
var ngCspAttribute = ngCspElement.getAttribute('ng-csp') ||
ngCspElement.getAttribute('data-ng-csp');
csp.rules = {
noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1),
noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1)
};
} else {
csp.rules = {
noUnsafeEval: noUnsafeEval(),
noInlineStyle: false
};
}
}
return csp.rules;
function noUnsafeEval() {
try {
/* jshint -W031, -W054 */
new Function('');
/* jshint +W031, +W054 */
return false;
} catch (e) {
return true;
}
}
};
/**
* @ngdoc directive
* @module ng
* @name ngJq
*
* @element ANY
* @param {string=} ngJq the name of the library available under `window`
* to be used for angular.element
* @description
* Use this directive to force the angular.element library. This should be
* used to force either jqLite by leaving ng-jq blank or setting the name of
* the jquery variable under window (eg. jQuery).
*
* Since angular looks for this directive when it is loaded (doesn't wait for the
* DOMContentLoaded event), it must be placed on an element that comes before the script
* which loads angular. Also, only the first instance of `ng-jq` will be used and all
* others ignored.
*
* @example
* This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
```html
<!doctype html>
<html ng-app ng-jq>
...
...
</html>
```
* @example
* This example shows how to use a jQuery based library of a different name.
* The library name must be available at the top most 'window'.
```html
<!doctype html>
<html ng-app ng-jq="jQueryLib">
...
...
</html>
```
*/
var jq = function() {
if (isDefined(jq.name_)) return jq.name_;
var el;
var i, ii = ngAttrPrefixes.length, prefix, name;
for (i = 0; i < ii; ++i) {
prefix = ngAttrPrefixes[i];
if (el = document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
name = el.getAttribute(prefix + 'jq');
break;
}
}
return (jq.name_ = name);
};
function concat(array1, array2, index) {
return array1.concat(slice.call(array2, index));
}
function sliceArgs(args, startIndex) {
return slice.call(args, startIndex || 0);
}
/* jshint -W101 */
/**
* @ngdoc function
* @name angular.bind
* @module ng
* @kind function
*
* @description
* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
* `fn`). You can supply optional `args` that are prebound to the function. This feature is also
* known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
* distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
*
* @param {Object} self Context which `fn` should be evaluated in.
* @param {function()} fn Function to be bound.
* @param {...*} args Optional arguments to be prebound to the `fn` function call.
* @returns {function()} Function that wraps the `fn` with all the specified bindings.
*/
/* jshint +W101 */
function bind(self, fn) {
var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
if (isFunction(fn) && !(fn instanceof RegExp)) {
return curryArgs.length
? function() {
return arguments.length
? fn.apply(self, concat(curryArgs, arguments, 0))
: fn.apply(self, curryArgs);
}
: function() {
return arguments.length
? fn.apply(self, arguments)
: fn.call(self);
};
} else {
// in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
return fn;
}
}
function toJsonReplacer(key, value) {
var val = value;
if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
val = undefined;
} else if (isWindow(value)) {
val = '$WINDOW';
} else if (value && document === value) {
val = '$DOCUMENT';
} else if (isScope(value)) {
val = '$SCOPE';
}
return val;
}
/**
* @ngdoc function
* @name angular.toJson
* @module ng
* @kind function
*
* @description
* Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
* stripped since angular uses this notation internally.
*
* @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
* @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
* If set to an integer, the JSON output will contain that many spaces per indentation.
* @returns {string|undefined} JSON-ified string representing `obj`.
*/
function toJson(obj, pretty) {
if (typeof obj === 'undefined') return undefined;
if (!isNumber(pretty)) {
pretty = pretty ? 2 : null;
}
return JSON.stringify(obj, toJsonReplacer, pretty);
}
/**
* @ngdoc function
* @name angular.fromJson
* @module ng
* @kind function
*
* @description
* Deserializes a JSON string.
*
* @param {string} json JSON string to deserialize.
* @returns {Object|Array|string|number} Deserialized JSON string.
*/
function fromJson(json) {
return isString(json)
? JSON.parse(json)
: json;
}
function timezoneToOffset(timezone, fallback) {
var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
}
function addDateMinutes(date, minutes) {
date = new Date(date.getTime());
date.setMinutes(date.getMinutes() + minutes);
return date;
}
function convertTimezoneToLocal(date, timezone, reverse) {
reverse = reverse ? -1 : 1;
var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset()));
}
/**
* @returns {string} Returns the string representation of the element.
*/
function startingTag(element) {
element = jqLite(element).clone();
try {
// turns out IE does not let you set .html() on elements which
// are not allowed to have children. So we just ignore it.
element.empty();
} catch (e) {}
var elemHtml = jqLite('<div>').append(element).html();
try {
return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
elemHtml.
match(/^(<[^>]+>)/)[1].
replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
} catch (e) {
return lowercase(elemHtml);
}
}
/////////////////////////////////////////////////
/**
* Tries to decode the URI component without throwing an exception.
*
* @private
* @param str value potential URI component to check.
* @returns {boolean} True if `value` can be decoded
* with the decodeURIComponent function.
*/
function tryDecodeURIComponent(value) {
try {
return decodeURIComponent(value);
} catch (e) {
// Ignore any invalid uri component
}
}
/**
* Parses an escaped url query string into key-value pairs.
* @returns {Object.<string,boolean|Array>}
*/
function parseKeyValue(/**string*/keyValue) {
var obj = {};
forEach((keyValue || "").split('&'), function(keyValue) {
var splitPoint, key, val;
if (keyValue) {
key = keyValue = keyValue.replace(/\+/g,'%20');
splitPoint = keyValue.indexOf('=');
if (splitPoint !== -1) {
key = keyValue.substring(0, splitPoint);
val = keyValue.substring(splitPoint + 1);
}
key = tryDecodeURIComponent(key);
if (isDefined(key)) {
val = isDefined(val) ? tryDecodeURIComponent(val) : true;
if (!hasOwnProperty.call(obj, key)) {
obj[key] = val;
} else if (isArray(obj[key])) {
obj[key].push(val);
} else {
obj[key] = [obj[key],val];
}
}
}
});
return obj;
}
function toKeyValue(obj) {
var parts = [];
forEach(obj, function(value, key) {
if (isArray(value)) {
forEach(value, function(arrayValue) {
parts.push(encodeUriQuery(key, true) +
(arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));
});
} else {
parts.push(encodeUriQuery(key, true) +
(value === true ? '' : '=' + encodeUriQuery(value, true)));
}
});
return parts.length ? parts.join('&') : '';
}
/**
* We need our custom method because encodeURIComponent is too aggressive and doesn't follow
* http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
* segments:
* segment = *pchar
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* pct-encoded = "%" HEXDIG HEXDIG
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/
function encodeUriSegment(val) {
return encodeUriQuery(val, true).
replace(/%26/gi, '&').
replace(/%3D/gi, '=').
replace(/%2B/gi, '+');
}
/**
* This method is intended for encoding *key* or *value* parts of query component. We need a custom
* method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
* encoded per http://tools.ietf.org/html/rfc3986:
* query = *( pchar / "/" / "?" )
* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* pct-encoded = "%" HEXDIG HEXDIG
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
* / "*" / "+" / "," / ";" / "="
*/
function encodeUriQuery(val, pctEncodeSpaces) {
return encodeURIComponent(val).
replace(/%40/gi, '@').
replace(/%3A/gi, ':').
replace(/%24/g, '$').
replace(/%2C/gi, ',').
replace(/%3B/gi, ';').
replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
}
var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
function getNgAttribute(element, ngAttr) {
var attr, i, ii = ngAttrPrefixes.length;
for (i = 0; i < ii; ++i) {
attr = ngAttrPrefixes[i] + ngAttr;
if (isString(attr = element.getAttribute(attr))) {
return attr;
}
}
return null;
}
/**
* @ngdoc directive
* @name ngApp
* @module ng
*
* @element ANY
* @param {angular.Module} ngApp an optional application
* {@link angular.module module} name to load.
* @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be
* created in "strict-di" mode. This means that the application will fail to invoke functions which
* do not use explicit function annotation (and are thus unsuitable for minification), as described
* in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in
* tracking down the root of these bugs.
*
* @description
*
* Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
* designates the **root element** of the application and is typically placed near the root element
* of the page - e.g. on the `<body>` or `<html>` tags.
*
* Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
* found in the document will be used to define the root element to auto-bootstrap as an
* application. To run multiple applications in an HTML document you must manually bootstrap them using
* {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
*
* You can specify an **AngularJS module** to be used as the root module for the application. This
* module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
* should contain the application code needed or have dependencies on other modules that will
* contain the code. See {@link angular.module} for more information.
*
* In the example below if the `ngApp` directive were not placed on the `html` element then the
* document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
* would not be resolved to `3`.
*
* `ngApp` is the easiest, and most common way to bootstrap an application.
*
<example module="ngAppDemo">
<file name="index.html">
<div ng-controller="ngAppDemoController">
I can add: {{a}} + {{b}} = {{ a+b }}
</div>
</file>
<file name="script.js">
angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
$scope.a = 1;
$scope.b = 2;
});
</file>
</example>
*
* Using `ngStrictDi`, you would see something like this:
*
<example ng-app-included="true">
<file name="index.html">
<div ng-app="ngAppStrictDemo" ng-strict-di>
<div ng-controller="GoodController1">
I can add: {{a}} + {{b}} = {{ a+b }}
<p>This renders because the controller does not fail to
instantiate, by using explicit annotation style (see
script.js for details)
</p>
</div>
<div ng-controller="GoodController2">
Name: <input ng-model="name"><br />
Hello, {{name}}!
<p>This renders because the controller does not fail to
instantiate, by using explicit annotation style
(see script.js for details)
</p>
</div>
<div ng-controller="BadController">
I can add: {{a}} + {{b}} = {{ a+b }}
<p>The controller could not be instantiated, due to relying
on automatic function annotations (which are disabled in
strict mode). As such, the content of this section is not
interpolated, and there should be an error in your web console.
</p>
</div>
</div>
</file>
<file name="script.js">
angular.module('ngAppStrictDemo', [])
// BadController will fail to instantiate, due to relying on automatic function annotation,
// rather than an explicit annotation
.controller('BadController', function($scope) {
$scope.a = 1;
$scope.b = 2;
})
// Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated,
// due to using explicit annotations using the array style and $inject property, respectively.
.controller('GoodController1', ['$scope', function($scope) {
$scope.a = 1;
$scope.b = 2;
}])
.controller('GoodController2', GoodController2);
function GoodController2($scope) {
$scope.name = "World";
}
GoodController2.$inject = ['$scope'];
</file>
<file name="style.css">
div[ng-controller] {
margin-bottom: 1em;
-webkit-border-radius: 4px;
border-radius: 4px;
border: 1px solid;
padding: .5em;
}
div[ng-controller^=Good] {
border-color: #d6e9c6;
background-color: #dff0d8;
color: #3c763d;
}
div[ng-controller^=Bad] {
border-color: #ebccd1;
background-color: #f2dede;
color: #a94442;
margin-bottom: 0;
}
</file>
</example>
*/
function angularInit(element, bootstrap) {
var appElement,
module,
config = {};
// The element `element` has priority over any other element
forEach(ngAttrPrefixes, function(prefix) {
var name = prefix + 'app';
if (!appElement && element.hasAttribute && element.hasAttribute(name)) {
appElement = element;
module = element.getAttribute(name);
}
});
forEach(ngAttrPrefixes, function(prefix) {
var name = prefix + 'app';
var candidate;
if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) {
appElement = candidate;
module = candidate.getAttribute(name);
}
});
if (appElement) {
config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
bootstrap(appElement, module ? [module] : [], config);
}
}
/**
* @ngdoc function
* @name angular.bootstrap
* @module ng
* @description
* Use this function to manually start up angular application.
*
* See: {@link guide/bootstrap Bootstrap}
*
* Note that Protractor based end-to-end tests cannot use this function to bootstrap manually.
* They must use {@link ng.directive:ngApp ngApp}.
*
* Angular will detect if it has been loaded into the browser more than once and only allow the
* first loaded script to be bootstrapped and will report a warning to the browser console for
* each of the subsequent scripts. This prevents strange results in applications, where otherwise
* multiple instances of Angular try to work on the DOM.
*
* ```html
* <!doctype html>
* <html>
* <body>
* <div ng-controller="WelcomeController">
* {{greeting}}
* </div>
*
* <script src="angular.js"></script>
* <script>
* var app = angular.module('demo', [])
* .controller('WelcomeController', function($scope) {
* $scope.greeting = 'Welcome!';
* });
* angular.bootstrap(document, ['demo']);
* </script>
* </body>
* </html>
* ```
*
* @param {DOMElement} element DOM element which is the root of angular application.
* @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
* Each item in the array should be the name of a predefined module or a (DI annotated)
* function that will be invoked by the injector as a `config` block.
* See: {@link angular.module modules}
* @param {Object=} config an object for defining configuration options for the application. The
* following keys are supported:
*
* * `strictDi` - disable automatic function annotation for the application. This is meant to
* assist in finding bugs which break minified code. Defaults to `false`.
*
* @returns {auto.$injector} Returns the newly created injector for this app.
*/
function bootstrap(element, modules, config) {
if (!isObject(config)) config = {};
var defaultConfig = {
strictDi: false
};
config = extend(defaultConfig, config);
var doBootstrap = function() {
element = jqLite(element);
if (element.injector()) {
var tag = (element[0] === document) ? 'document' : startingTag(element);
//Encode angle brackets to prevent input from being sanitized to empty string #8683
throw ngMinErr(
'btstrpd',
"App Already Bootstrapped with this Element '{0}'",
tag.replace(/</,'<').replace(/>/,'>'));
}
modules = modules || [];
modules.unshift(['$provide', function($provide) {
$provide.value('$rootElement', element);
}]);
if (config.debugInfoEnabled) {
// Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`.
modules.push(['$compileProvider', function($compileProvider) {
$compileProvider.debugInfoEnabled(true);
}]);
}
modules.unshift('ng');
var injector = createInjector(modules, config.strictDi);
injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
function bootstrapApply(scope, element, compile, injector) {
scope.$apply(function() {
element.data('$injector', injector);
compile(element)(scope);
});
}]
);
return injector;
};
var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/;
var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) {
config.debugInfoEnabled = true;
window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, '');
}
if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
return doBootstrap();
}
window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
angular.resumeBootstrap = function(extraModules) {
forEach(extraModules, function(module) {
modules.push(module);
});
return doBootstrap();
};
if (isFunction(angular.resumeDeferredBootstrap)) {
angular.resumeDeferredBootstrap();
}
}
/**
* @ngdoc function
* @name angular.reloadWithDebugInfo
* @module ng
* @description
* Use this function to reload the current application with debug information turned on.
* This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`.
*
* See {@link ng.$compileProvider#debugInfoEnabled} for more.
*/
function reloadWithDebugInfo() {
window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name;
window.location.reload();
}
/**
* @name angular.getTestability
* @module ng
* @description
* Get the testability service for the instance of Angular on the given
* element.
* @param {DOMElement} element DOM element which is the root of angular application.
*/
function getTestability(rootElement) {
var injector = angular.element(rootElement).injector();
if (!injector) {
throw ngMinErr('test',
'no injector found for element argument to getTestability');
}
return injector.get('$$testability');
}
var SNAKE_CASE_REGEXP = /[A-Z]/g;
function snake_case(name, separator) {
separator = separator || '_';
return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
return (pos ? separator : '') + letter.toLowerCase();
});
}
var bindJQueryFired = false;
var skipDestroyOnNextJQueryCleanData;
function bindJQuery() {
var originalCleanData;
if (bindJQueryFired) {
return;
}
// bind to jQuery if present;
var jqName = jq();
jQuery = isUndefined(jqName) ? window.jQuery : // use jQuery (if present)
!jqName ? undefined : // use jqLite
window[jqName]; // use jQuery specified by `ngJq`
// Use jQuery if it exists with proper functionality, otherwise default to us.
// Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
// Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
// versions. It will not work for sure with jQuery <1.7, though.
if (jQuery && jQuery.fn.on) {
jqLite = jQuery;
extend(jQuery.fn, {
scope: JQLitePrototype.scope,
isolateScope: JQLitePrototype.isolateScope,
controller: JQLitePrototype.controller,
injector: JQLitePrototype.injector,
inheritedData: JQLitePrototype.inheritedData
});
// All nodes removed from the DOM via various jQuery APIs like .remove()
// are passed through jQuery.cleanData. Monkey-patch this method to fire
// the $destroy event on all removed nodes.
originalCleanData = jQuery.cleanData;
jQuery.cleanData = function(elems) {
var events;
if (!skipDestroyOnNextJQueryCleanData) {
for (var i = 0, elem; (elem = elems[i]) != null; i++) {
events = jQuery._data(elem, "events");
if (events && events.$destroy) {
jQuery(elem).triggerHandler('$destroy');
}
}
} else {
skipDestroyOnNextJQueryCleanData = false;
}
originalCleanData(elems);
};
} else {
jqLite = JQLite;
}
angular.element = jqLite;
// Prevent double-proxying.
bindJQueryFired = true;
}
/**
* throw error if the argument is falsy.
*/
function assertArg(arg, name, reason) {
if (!arg) {
throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required"));
}
return arg;
}
function assertArgFn(arg, name, acceptArrayAnnotation) {
if (acceptArrayAnnotation && isArray(arg)) {
arg = arg[arg.length - 1];
}
assertArg(isFunction(arg), name, 'not a function, got ' +
(arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
return arg;
}
/**
* throw error if the name given is hasOwnProperty
* @param {String} name the name to test
* @param {String} context the context in which the name is used, such as module or directive
*/
function assertNotHasOwnProperty(name, context) {
if (name === 'hasOwnProperty') {
throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context);
}
}
/**
* Return the value accessible from the object by path. Any undefined traversals are ignored
* @param {Object} obj starting object
* @param {String} path path to traverse
* @param {boolean} [bindFnToScope=true]
* @returns {Object} value as accessible by path
*/
//TODO(misko): this function needs to be removed
function getter(obj, path, bindFnToScope) {
if (!path) return obj;
var keys = path.split('.');
var key;
var lastInstance = obj;
var len = keys.length;
for (var i = 0; i < len; i++) {
key = keys[i];
if (obj) {
obj = (lastInstance = obj)[key];
}
}
if (!bindFnToScope && isFunction(obj)) {
return bind(lastInstance, obj);
}
return obj;
}
/**
* Return the DOM siblings between the first and last node in the given array.
* @param {Array} array like object
* @returns {Array} the inputted object or a jqLite collection containing the nodes
*/
function getBlockNodes(nodes) {
// TODO(perf): update `nodes` instead of creating a new object?
var node = nodes[0];
var endNode = nodes[nodes.length - 1];
var blockNodes;
for (var i = 1; node !== endNode && (node = node.nextSibling); i++) {
if (blockNodes || nodes[i] !== node) {
if (!blockNodes) {
blockNodes = jqLite(slice.call(nodes, 0, i));
}
blockNodes.push(node);
}
}
return blockNodes || nodes;
}
/**
* Creates a new object without a prototype. This object is useful for lookup without having to
* guard against prototypically inherited properties via hasOwnProperty.
*
* Related micro-benchmarks:
* - http://jsperf.com/object-create2
* - http://jsperf.com/proto-map-lookup/2
* - http://jsperf.com/for-in-vs-object-keys2
*
* @returns {Object}
*/
function createMap() {
return Object.create(null);
}
var NODE_TYPE_ELEMENT = 1;
var NODE_TYPE_ATTRIBUTE = 2;
var NODE_TYPE_TEXT = 3;
var NODE_TYPE_COMMENT = 8;
var NODE_TYPE_DOCUMENT = 9;
var NODE_TYPE_DOCUMENT_FRAGMENT = 11;
/**
* @ngdoc type
* @name angular.Module
* @module ng
* @description
*
* Interface for configuring angular {@link angular.module modules}.
*/
function setupModuleLoader(window) {
var $injectorMinErr = minErr('$injector');
var ngMinErr = minErr('ng');
function ensure(obj, name, factory) {
return obj[name] || (obj[name] = factory());
}
var angular = ensure(window, 'angular', Object);
// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
angular.$$minErr = angular.$$minErr || minErr;
return ensure(angular, 'module', function() {
/** @type {Object.<string, angular.Module>} */
var modules = {};
/**
* @ngdoc function
* @name angular.module
* @module ng
* @description
*
* The `angular.module` is a global place for creating, registering and retrieving Angular
* modules.
* All modules (angular core or 3rd party) that should be available to an application must be
* registered using this mechanism.
*
* Passing one argument retrieves an existing {@link angular.Module},
* whereas passing more than one argument creates a new {@link angular.Module}
*
*
* # Module
*
* A module is a collection of services, directives, controllers, filters, and configuration information.
* `angular.module` is used to configure the {@link auto.$injector $injector}.
*
* ```js
* // Create a new module
* var myModule = angular.module('myModule', []);
*
* // register a new service
* myModule.value('appName', 'MyCoolApp');
*
* // configure existing services inside initialization blocks.
* myModule.config(['$locationProvider', function($locationProvider) {
* // Configure existing providers
* $locationProvider.hashPrefix('!');
* }]);
* ```
*
* Then you can create an injector and load your modules like this:
*
* ```js
* var injector = angular.injector(['ng', 'myModule'])
* ```
*
* However it's more likely that you'll just use
* {@link ng.directive:ngApp ngApp} or
* {@link angular.bootstrap} to simplify this process for you.
*
* @param {!string} name The name of the module to create or retrieve.
* @param {!Array.<string>=} requires If specified then new module is being created. If
* unspecified then the module is being retrieved for further configuration.
* @param {Function=} configFn Optional configuration function for the module. Same as
* {@link angular.Module#config Module#config()}.
* @returns {module} new module with the {@link angular.Module} api.
*/
return function module(name, requires, configFn) {
var assertNotHasOwnProperty = function(name, context) {
if (name === 'hasOwnProperty') {
throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
}
};
assertNotHasOwnProperty(name, 'module');
if (requires && modules.hasOwnProperty(name)) {
modules[name] = null;
}
return ensure(modules, name, function() {
if (!requires) {
throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
"the module name or forgot to load it. If registering a module ensure that you " +
"specify the dependencies as the second argument.", name);
}
/** @type {!Array.<Array.<*>>} */
var invokeQueue = [];
/** @type {!Array.<Function>} */
var configBlocks = [];
/** @type {!Array.<Function>} */
var runBlocks = [];
var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
/** @type {angular.Module} */
var moduleInstance = {
// Private state
_invokeQueue: invokeQueue,
_configBlocks: configBlocks,
_runBlocks: runBlocks,
/**
* @ngdoc property
* @name angular.Module#requires
* @module ng
*
* @description
* Holds the list of modules which the injector will load before the current module is
* loaded.
*/
requires: requires,
/**
* @ngdoc property
* @name angular.Module#name
* @module ng
*
* @description
* Name of the module.
*/
name: name,
/**
* @ngdoc method
* @name angular.Module#provider
* @module ng
* @param {string} name service name
* @param {Function} providerType Construction function for creating new instance of the
* service.
* @description
* See {@link auto.$provide#provider $provide.provider()}.
*/
provider: invokeLaterAndSetModuleName('$provide', 'provider'),
/**
* @ngdoc method
* @name angular.Module#factory
* @module ng
* @param {string} name service name
* @param {Function} providerFunction Function for creating new instance of the service.
* @description
* See {@link auto.$provide#factory $provide.factory()}.
*/
factory: invokeLaterAndSetModuleName('$provide', 'factory'),
/**
* @ngdoc method
* @name angular.Module#service
* @module ng
* @param {string} name service name
* @param {Function} constructor A constructor function that will be instantiated.
* @description
* See {@link auto.$provide#service $provide.service()}.
*/
service: invokeLaterAndSetModuleName('$provide', 'service'),
/**
* @ngdoc method
* @name angular.Module#value
* @module ng
* @param {string} name service name
* @param {*} object Service instance object.
* @description
* See {@link auto.$provide#value $provide.value()}.
*/
value: invokeLater('$provide', 'value'),
/**
* @ngdoc method
* @name angular.Module#constant
* @module ng
* @param {string} name constant name
* @param {*} object Constant value.
* @description
* Because the constants are fixed, they get applied before other provide methods.
* See {@link auto.$provide#constant $provide.constant()}.
*/
constant: invokeLater('$provide', 'constant', 'unshift'),
/**
* @ngdoc method
* @name angular.Module#decorator
* @module ng
* @param {string} The name of the service to decorate.
* @param {Function} This function will be invoked when the service needs to be
* instantiated and should return the decorated service instance.
* @description
* See {@link auto.$provide#decorator $provide.decorator()}.
*/
decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
/**
* @ngdoc method
* @name angular.Module#animation
* @module ng
* @param {string} name animation name
* @param {Function} animationFactory Factory function for creating new instance of an
* animation.
* @description
*
* **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
*
*
* Defines an animation hook that can be later used with
* {@link $animate $animate} service and directives that use this service.
*
* ```js
* module.animation('.animation-name', function($inject1, $inject2) {
* return {
* eventName : function(element, done) {
* //code to run the animation
* //once complete, then run done()
* return function cancellationFunction(element) {
* //code to cancel the animation
* }
* }
* }
* })
* ```
*
* See {@link ng.$animateProvider#register $animateProvider.register()} and
* {@link ngAnimate ngAnimate module} for more information.
*/
animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
/**
* @ngdoc method
* @name angular.Module#filter
* @module ng
* @param {string} name Filter name - this must be a valid angular expression identifier
* @param {Function} filterFactory Factory function for creating new instance of filter.
* @description
* See {@link ng.$filterProvider#register $filterProvider.register()}.
*
* <div class="alert alert-warning">
* **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
* Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
* your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
* (`myapp_subsection_filterx`).
* </div>
*/
filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
/**
* @ngdoc method
* @name angular.Module#controller
* @module ng
* @param {string|Object} name Controller name, or an object map of controllers where the
* keys are the names and the values are the constructors.
* @param {Function} constructor Controller constructor function.
* @description
* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
*/
controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
/**
* @ngdoc method
* @name angular.Module#directive
* @module ng
* @param {string|Object} name Directive name, or an object map of directives where the
* keys are the names and the values are the factories.
* @param {Function} directiveFactory Factory function for creating new instance of
* directives.
* @description
* See {@link ng.$compileProvider#directive $compileProvider.directive()}.
*/
directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
/**
* @ngdoc method
* @name angular.Module#config
* @module ng
* @param {Function} configFn Execute this function on module load. Useful for service
* configuration.
* @description
* Use this method to register work which needs to be performed on module loading.
* For more about how to configure services, see
* {@link providers#provider-recipe Provider Recipe}.
*/
config: config,
/**
* @ngdoc method
* @name angular.Module#run
* @module ng
* @param {Function} initializationFn Execute this function after injector creation.
* Useful for application initialization.
* @description
* Use this method to register work which should be performed when the injector is done
* loading all modules.
*/
run: function(block) {
runBlocks.push(block);
return this;
}
};
if (configFn) {
config(configFn);
}
return moduleInstance;
/**
* @param {string} provider
* @param {string} method
* @param {String=} insertMethod
* @returns {angular.Module}
*/
function invokeLater(provider, method, insertMethod, queue) {
if (!queue) queue = invokeQueue;
return function() {
queue[insertMethod || 'push']([provider, method, arguments]);
return moduleInstance;
};
}
/**
* @param {string} provider
* @param {string} method
* @returns {angular.Module}
*/
function invokeLaterAndSetModuleName(provider, method) {
return function(recipeName, factoryFunction) {
if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
invokeQueue.push([provider, method, arguments]);
return moduleInstance;
};
}
});
};
});
}
/* global: toDebugString: true */
function serializeObject(obj) {
var seen = [];
return JSON.stringify(obj, function(key, val) {
val = toJsonReplacer(key, val);
if (isObject(val)) {
if (seen.indexOf(val) >= 0) return '...';
seen.push(val);
}
return val;
});
}
function toDebugString(obj) {
if (typeof obj === 'function') {
return obj.toString().replace(/ \{[\s\S]*$/, '');
} else if (isUndefined(obj)) {
return 'undefined';
} else if (typeof obj !== 'string') {
return serializeObject(obj);
}
return obj;
}
/* global angularModule: true,
version: true,
$CompileProvider,
htmlAnchorDirective,
inputDirective,
inputDirective,
formDirective,
scriptDirective,
selectDirective,
styleDirective,
optionDirective,
ngBindDirective,
ngBindHtmlDirective,
ngBindTemplateDirective,
ngClassDirective,
ngClassEvenDirective,
ngClassOddDirective,
ngCloakDirective,
ngControllerDirective,
ngFormDirective,
ngHideDirective,
ngIfDirective,
ngIncludeDirective,
ngIncludeFillContentDirective,
ngInitDirective,
ngNonBindableDirective,
ngPluralizeDirective,
ngRepeatDirective,
ngShowDirective,
ngStyleDirective,
ngSwitchDirective,
ngSwitchWhenDirective,
ngSwitchDefaultDirective,
ngOptionsDirective,
ngTranscludeDirective,
ngModelDirective,
ngListDirective,
ngChangeDirective,
patternDirective,
patternDirective,
requiredDirective,
requiredDirective,
minlengthDirective,
minlengthDirective,
maxlengthDirective,
maxlengthDirective,
ngValueDirective,
ngModelOptionsDirective,
ngAttributeAliasDirectives,
ngEventDirectives,
$AnchorScrollProvider,
$AnimateProvider,
$CoreAnimateCssProvider,
$$CoreAnimateQueueProvider,
$$CoreAnimateRunnerProvider,
$BrowserProvider,
$CacheFactoryProvider,
$ControllerProvider,
$DocumentProvider,
$ExceptionHandlerProvider,
$FilterProvider,
$$ForceReflowProvider,
$InterpolateProvider,
$IntervalProvider,
$$HashMapProvider,
$HttpProvider,
$HttpParamSerializerProvider,
$HttpParamSerializerJQLikeProvider,
$HttpBackendProvider,
$xhrFactoryProvider,
$LocationProvider,
$LogProvider,
$ParseProvider,
$RootScopeProvider,
$QProvider,
$$QProvider,
$$SanitizeUriProvider,
$SceProvider,
$SceDelegateProvider,
$SnifferProvider,
$TemplateCacheProvider,
$TemplateRequestProvider,
$$TestabilityProvider,
$TimeoutProvider,
$$RAFProvider,
$WindowProvider,
$$jqLiteProvider,
$$CookieReaderProvider
*/
/**
* @ngdoc object
* @name angular.version
* @module ng
* @description
* An object that contains information about the current AngularJS version.
*
* This object has the following properties:
*
* - `full` – `{string}` – Full version string, such as "0.9.18".
* - `major` – `{number}` – Major version number, such as "0".
* - `minor` – `{number}` – Minor version number, such as "9".
* - `dot` – `{number}` – Dot version number, such as "18".
* - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
*/
var version = {
full: '1.4.8', // all of these placeholder strings will be replaced by grunt's
major: 1, // package task
minor: 4,
dot: 8,
codeName: 'ice-manipulation'
};
function publishExternalAPI(angular) {
extend(angular, {
'bootstrap': bootstrap,
'copy': copy,
'extend': extend,
'merge': merge,
'equals': equals,
'element': jqLite,
'forEach': forEach,
'injector': createInjector,
'noop': noop,
'bind': bind,
'toJson': toJson,
'fromJson': fromJson,
'identity': identity,
'isUndefined': isUndefined,
'isDefined': isDefined,
'isString': isString,
'isFunction': isFunction,
'isObject': isObject,
'isNumber': isNumber,
'isElement': isElement,
'isArray': isArray,
'version': version,
'isDate': isDate,
'lowercase': lowercase,
'uppercase': uppercase,
'callbacks': {counter: 0},
'getTestability': getTestability,
'$$minErr': minErr,
'$$csp': csp,
'reloadWithDebugInfo': reloadWithDebugInfo
});
angularModule = setupModuleLoader(window);
angularModule('ng', ['ngLocale'], ['$provide',
function ngModule($provide) {
// $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
$provide.provider({
$$sanitizeUri: $$SanitizeUriProvider
});
$provide.provider('$compile', $CompileProvider).
directive({
a: htmlAnchorDirective,
input: inputDirective,
textarea: inputDirective,
form: formDirective,
script: scriptDirective,
select: selectDirective,
style: styleDirective,
option: optionDirective,
ngBind: ngBindDirective,
ngBindHtml: ngBindHtmlDirective,
ngBindTemplate: ngBindTemplateDirective,
ngClass: ngClassDirective,
ngClassEven: ngClassEvenDirective,
ngClassOdd: ngClassOddDirective,
ngCloak: ngCloakDirective,
ngController: ngControllerDirective,
ngForm: ngFormDirective,
ngHide: ngHideDirective,
ngIf: ngIfDirective,
ngInclude: ngIncludeDirective,
ngInit: ngInitDirective,
ngNonBindable: ngNonBindableDirective,
ngPluralize: ngPluralizeDirective,
ngRepeat: ngRepeatDirective,
ngShow: ngShowDirective,
ngStyle: ngStyleDirective,
ngSwitch: ngSwitchDirective,
ngSwitchWhen: ngSwitchWhenDirective,
ngSwitchDefault: ngSwitchDefaultDirective,
ngOptions: ngOptionsDirective,
ngTransclude: ngTranscludeDirective,
ngModel: ngModelDirective,
ngList: ngListDirective,
ngChange: ngChangeDirective,
pattern: patternDirective,
ngPattern: patternDirective,
required: requiredDirective,
ngRequired: requiredDirective,
minlength: minlengthDirective,
ngMinlength: minlengthDirective,
maxlength: maxlengthDirective,
ngMaxlength: maxlengthDirective,
ngValue: ngValueDirective,
ngModelOptions: ngModelOptionsDirective
}).
directive({
ngInclude: ngIncludeFillContentDirective
}).
directive(ngAttributeAliasDirectives).
directive(ngEventDirectives);
$provide.provider({
$anchorScroll: $AnchorScrollProvider,
$animate: $AnimateProvider,
$animateCss: $CoreAnimateCssProvider,
$$animateQueue: $$CoreAnimateQueueProvider,
$$AnimateRunner: $$CoreAnimateRunnerProvider,
$browser: $BrowserProvider,
$cacheFactory: $CacheFactoryProvider,
$controller: $ControllerProvider,
$document: $DocumentProvider,
$exceptionHandler: $ExceptionHandlerProvider,
$filter: $FilterProvider,
$$forceReflow: $$ForceReflowProvider,
$interpolate: $InterpolateProvider,
$interval: $IntervalProvider,
$http: $HttpProvider,
$httpParamSerializer: $HttpParamSerializerProvider,
$httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
$httpBackend: $HttpBackendProvider,
$xhrFactory: $xhrFactoryProvider,
$location: $LocationProvider,
$log: $LogProvider,
$parse: $ParseProvider,
$rootScope: $RootScopeProvider,
$q: $QProvider,
$$q: $$QProvider,
$sce: $SceProvider,
$sceDelegate: $SceDelegateProvider,
$sniffer: $SnifferProvider,
$templateCache: $TemplateCacheProvider,
$templateRequest: $TemplateRequestProvider,
$$testability: $$TestabilityProvider,
$timeout: $TimeoutProvider,
$window: $WindowProvider,
$$rAF: $$RAFProvider,
$$jqLite: $$jqLiteProvider,
$$HashMap: $$HashMapProvider,
$$cookieReader: $$CookieReaderProvider
});
}
]);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Any commits to this file should be reviewed with security in mind. *
* Changes to this file can potentially create security vulnerabilities. *
* An approval from 2 Core members with history of modifying *
* this file is required. *
* *
* Does the change somehow allow for arbitrary javascript to be executed? *
* Or allows for someone to change the prototype of built-in objects? *
* Or gives undesired access to variables likes document or window? *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* global JQLitePrototype: true,
addEventListenerFn: true,
removeEventListenerFn: true,
BOOLEAN_ATTR: true,
ALIASED_ATTR: true,
*/
//////////////////////////////////
//JQLite
//////////////////////////////////
/**
* @ngdoc function
* @name angular.element
* @module ng
* @kind function
*
* @description
* Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
*
* If jQuery is available, `angular.element` is an alias for the
* [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
* delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."
*
* <div class="alert alert-success">jqLite is a tiny, API-compatible subset of jQuery that allows
* Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most
* commonly needed functionality with the goal of having a very small footprint.</div>
*
* To use `jQuery`, simply ensure it is loaded before the `angular.js` file.
*
* <div class="alert">**Note:** all element references in Angular are always wrapped with jQuery or
* jqLite; they are never raw DOM references.</div>
*
* ## Angular's jqLite
* jqLite provides only the following jQuery methods:
*
* - [`addClass()`](http://api.jquery.com/addClass/)
* - [`after()`](http://api.jquery.com/after/)
* - [`append()`](http://api.jquery.com/append/)
* - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
* - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
* - [`children()`](http://api.jquery.com/children/) - Does not support selectors
* - [`clone()`](http://api.jquery.com/clone/)
* - [`contents()`](http://api.jquery.com/contents/)
* - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`. As a setter, does not convert numbers to strings or append 'px'.
* - [`data()`](http://api.jquery.com/data/)
* - [`detach()`](http://api.jquery.com/detach/)
* - [`empty()`](http://api.jquery.com/empty/)
* - [`eq()`](http://api.jquery.com/eq/)
* - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
* - [`hasClass()`](http://api.jquery.com/hasClass/)
* - [`html()`](http://api.jquery.com/html/)
* - [`next()`](http://api.jquery.com/next/) - Does not support selectors
* - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
* - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter
* - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors
* - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
* - [`prepend()`](http://api.jquery.com/prepend/)
* - [`prop()`](http://api.jquery.com/prop/)
* - [`ready()`](http://api.jquery.com/ready/)
* - [`remove()`](http://api.jquery.com/remove/)
* - [`removeAttr()`](http://api.jquery.com/removeAttr/)
* - [`removeClass()`](http://api.jquery.com/removeClass/)
* - [`removeData()`](http://api.jquery.com/removeData/)
* - [`replaceWith()`](http://api.jquery.com/replaceWith/)
* - [`text()`](http://api.jquery.com/text/)
* - [`toggleClass()`](http://api.jquery.com/toggleClass/)
* - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
* - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter
* - [`val()`](http://api.jquery.com/val/)
* - [`wrap()`](http://api.jquery.com/wrap/)
*
* ## jQuery/jqLite Extras
* Angular also provides the following additional methods and events to both jQuery and jqLite:
*
* ### Events
* - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
* on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM
* element before it is removed.
*
* ### Methods
* - `controller(name)` - retrieves the controller of the current element or its parent. By default
* retrieves controller associated with the `ngController` directive. If `name` is provided as
* camelCase directive name, then the controller for this directive will be retrieved (e.g.
* `'ngModel'`).
* - `injector()` - retrieves the injector of the current element or its parent.
* - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
* element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
* be enabled.
* - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
* current element. This getter should be used only on elements that contain a directive which starts a new isolate
* scope. Calling `scope()` on this element always returns the original non-isolate scope.
* Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
* - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
* parent element is reached.
*
* @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
* @returns {Object} jQuery object.
*/
JQLite.expando = 'ng339';
var jqCache = JQLite.cache = {},
jqId = 1,
addEventListenerFn = function(element, type, fn) {
element.addEventListener(type, fn, false);
},
removeEventListenerFn = function(element, type, fn) {
element.removeEventListener(type, fn, false);
};
/*
* !!! This is an undocumented "private" function !!!
*/
JQLite._data = function(node) {
//jQuery always returns an object on cache miss
return this.cache[node[this.expando]] || {};
};
function jqNextId() { return ++jqId; }
var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
var MOZ_HACK_REGEXP = /^moz([A-Z])/;
var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"};
var jqLiteMinErr = minErr('jqLite');
/**
* Converts snake_case to camelCase.
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/
function camelCase(name) {
return name.
replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
return offset ? letter.toUpperCase() : letter;
}).
replace(MOZ_HACK_REGEXP, 'Moz$1');
}
var SINGLE_TAG_REGEXP = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;
var HTML_REGEXP = /<|&#?\w+;/;
var TAG_NAME_REGEXP = /<([\w:-]+)/;
var XHTML_TAG_REGEXP = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi;
var wrapMap = {
'option': [1, '<select multiple="multiple">', '</select>'],
'thead': [1, '<table>', '</table>'],
'col': [2, '<table><colgroup>', '</colgroup></table>'],
'tr': [2, '<table><tbody>', '</tbody></table>'],
'td': [3, '<table><tbody><tr>', '</tr></tbody></table>'],
'_default': [0, "", ""]
};
wrapMap.optgroup = wrapMap.option;
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;
function jqLiteIsTextNode(html) {
return !HTML_REGEXP.test(html);
}
function jqLiteAcceptsData(node) {
// The window object can accept data but has no nodeType
// Otherwise we are only interested in elements (1) and documents (9)
var nodeType = node.nodeType;
return nodeType === NODE_TYPE_ELEMENT || !nodeType || nodeType === NODE_TYPE_DOCUMENT;
}
function jqLiteHasData(node) {
for (var key in jqCache[node.ng339]) {
return true;
}
return false;
}
function jqLiteBuildFragment(html, context) {
var tmp, tag, wrap,
fragment = context.createDocumentFragment(),
nodes = [], i;
if (jqLiteIsTextNode(html)) {
// Convert non-html into a text node
nodes.push(context.createTextNode(html));
} else {
// Convert html into DOM nodes
tmp = tmp || fragment.appendChild(context.createElement("div"));
tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase();
wrap = wrapMap[tag] || wrapMap._default;
tmp.innerHTML = wrap[1] + html.replace(XHTML_TAG_REGEXP, "<$1></$2>") + wrap[2];
// Descend through wrappers to the right content
i = wrap[0];
while (i--) {
tmp = tmp.lastChild;
}
nodes = concat(nodes, tmp.childNodes);
tmp = fragment.firstChild;
tmp.textContent = "";
}
// Remove wrapper from fragment
fragment.textContent = "";
fragment.innerHTML = ""; // Clear inner HTML
forEach(nodes, function(node) {
fragment.appendChild(node);
});
return fragment;
}
function jqLiteParseHTML(html, context) {
context = context || document;
var parsed;
if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
return [context.createElement(parsed[1])];
}
if ((parsed = jqLiteBuildFragment(html, context))) {
return parsed.childNodes;
}
return [];
}
// IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
var jqLiteContains = Node.prototype.contains || function(arg) {
// jshint bitwise: false
return !!(this.compareDocumentPosition(arg) & 16);
// jshint bitwise: true
};
/////////////////////////////////////////////
function JQLite(element) {
if (element instanceof JQLite) {
return element;
}
var argIsString;
if (isString(element)) {
element = trim(element);
argIsString = true;
}
if (!(this instanceof JQLite)) {
if (argIsString && element.charAt(0) != '<') {
throw jqLiteMinErr('nosel', 'Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element');
}
return new JQLite(element);
}
if (argIsString) {
jqLiteAddNodes(this, jqLiteParseHTML(element));
} else {
jqLiteAddNodes(this, element);
}
}
function jqLiteClone(element) {
return element.cloneNode(true);
}
function jqLiteDealoc(element, onlyDescendants) {
if (!onlyDescendants) jqLiteRemoveData(element);
if (element.querySelectorAll) {
var descendants = element.querySelectorAll('*');
for (var i = 0, l = descendants.length; i < l; i++) {
jqLiteRemoveData(descendants[i]);
}
}
}
function jqLiteOff(element, type, fn, unsupported) {
if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument');
var expandoStore = jqLiteExpandoStore(element);
var events = expandoStore && expandoStore.events;
var handle = expandoStore && expandoStore.handle;
if (!handle) return; //no listeners registered
if (!type) {
for (type in events) {
if (type !== '$destroy') {
removeEventListenerFn(element, type, handle);
}
delete events[type];
}
} else {
var removeHandler = function(type) {
var listenerFns = events[type];
if (isDefined(fn)) {
arrayRemove(listenerFns || [], fn);
}
if (!(isDefined(fn) && listenerFns && listenerFns.length > 0)) {
removeEventListenerFn(element, type, handle);
delete events[type];
}
};
forEach(type.split(' '), function(type) {
removeHandler(type);
if (MOUSE_EVENT_MAP[type]) {
removeHandler(MOUSE_EVENT_MAP[type]);
}
});
}
}
function jqLiteRemoveData(element, name) {
var expandoId = element.ng339;
var expandoStore = expandoId && jqCache[expandoId];
if (expandoStore) {
if (name) {
delete expandoStore.data[name];
return;
}
if (expandoStore.handle) {
if (expandoStore.events.$destroy) {
expandoStore.handle({}, '$destroy');
}
jqLiteOff(element);
}
delete jqCache[expandoId];
element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it
}
}
function jqLiteExpandoStore(element, createIfNecessary) {
var expandoId = element.ng339,
expandoStore = expandoId && jqCache[expandoId];
if (createIfNecessary && !expandoStore) {
element.ng339 = expandoId = jqNextId();
expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined};
}
return expandoStore;
}
function jqLiteData(element, key, value) {
if (jqLiteAcceptsData(element)) {
var isSimpleSetter = isDefined(value);
var isSimpleGetter = !isSimpleSetter && key && !isObject(key);
var massGetter = !key;
var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter);
var data = expandoStore && expandoStore.data;
if (isSimpleSetter) { // data('key', value)
data[key] = value;
} else {
if (massGetter) { // data()
return data;
} else {
if (isSimpleGetter) { // data('key')
// don't force creation of expandoStore if it doesn't exist yet
return data && data[key];
} else { // mass-setter: data({key1: val1, key2: val2})
extend(data, key);
}
}
}
}
}
function jqLiteHasClass(element, selector) {
if (!element.getAttribute) return false;
return ((" " + (element.getAttribute('class') || '') + " ").replace(/[\n\t]/g, " ").
indexOf(" " + selector + " ") > -1);
}
function jqLiteRemoveClass(element, cssClasses) {
if (cssClasses && element.setAttribute) {
forEach(cssClasses.split(' '), function(cssClass) {
element.setAttribute('class', trim(
(" " + (element.getAttribute('class') || '') + " ")
.replace(/[\n\t]/g, " ")
.replace(" " + trim(cssClass) + " ", " "))
);
});
}
}
function jqLiteAddClass(element, cssClasses) {
if (cssClasses && element.setAttribute) {
var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ')
.replace(/[\n\t]/g, " ");
forEach(cssClasses.split(' '), function(cssClass) {
cssClass = trim(cssClass);
if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {
existingClasses += cssClass + ' ';
}
});
element.setAttribute('class', trim(existingClasses));
}
}
function jqLiteAddNodes(root, elements) {
// THIS CODE IS VERY HOT. Don't make changes without benchmarking.
if (elements) {
// if a Node (the most common case)
if (elements.nodeType) {
root[root.length++] = elements;
} else {
var length = elements.length;
// if an Array or NodeList and not a Window
if (typeof length === 'number' && elements.window !== elements) {
if (length) {
for (var i = 0; i < length; i++) {
root[root.length++] = elements[i];
}
}
} else {
root[root.length++] = elements;
}
}
}
}
function jqLiteController(element, name) {
return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller');
}
function jqLiteInheritedData(element, name, value) {
// if element is the document object work with the html element instead
// this makes $(document).scope() possible
if (element.nodeType == NODE_TYPE_DOCUMENT) {
element = element.documentElement;
}
var names = isArray(name) ? name : [name];
while (element) {
for (var i = 0, ii = names.length; i < ii; i++) {
if (isDefined(value = jqLite.data(element, names[i]))) return value;
}
// If dealing with a document fragment node with a host element, and no parent, use the host
// element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM
// to lookup parent controllers.
element = element.parentNode || (element.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && element.host);
}
}
function jqLiteEmpty(element) {
jqLiteDealoc(element, true);
while (element.firstChild) {
element.removeChild(element.firstChild);
}
}
function jqLiteRemove(element, keepData) {
if (!keepData) jqLiteDealoc(element);
var parent = element.parentNode;
if (parent) parent.removeChild(element);
}
function jqLiteDocumentLoaded(action, win) {
win = win || window;
if (win.document.readyState === 'complete') {
// Force the action to be run async for consistent behaviour
// from the action's point of view
// i.e. it will definitely not be in a $apply
win.setTimeout(action);
} else {
// No need to unbind this handler as load is only ever called once
jqLite(win).on('load', action);
}
}
//////////////////////////////////////////
// Functions which are declared directly.
//////////////////////////////////////////
var JQLitePrototype = JQLite.prototype = {
ready: function(fn) {
var fired = false;
function trigger() {
if (fired) return;
fired = true;
fn();
}
// check if document is already loaded
if (document.readyState === 'complete') {
setTimeout(trigger);
} else {
this.on('DOMContentLoaded', trigger); // works for modern browsers and IE9
// we can not use jqLite since we are not done loading and jQuery could be loaded later.
// jshint -W064
JQLite(window).on('load', trigger); // fallback to window.onload for others
// jshint +W064
}
},
toString: function() {
var value = [];
forEach(this, function(e) { value.push('' + e);});
return '[' + value.join(', ') + ']';
},
eq: function(index) {
return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);
},
length: 0,
push: push,
sort: [].sort,
splice: [].splice
};
//////////////////////////////////////////
// Functions iterating getter/setters.
// these functions return self on setter and
// value on get.
//////////////////////////////////////////
var BOOLEAN_ATTR = {};
forEach('multiple,selected,checked,disabled,readOnly,required,open'.split(','), function(value) {
BOOLEAN_ATTR[lowercase(value)] = value;
});
var BOOLEAN_ELEMENTS = {};
forEach('input,select,option,textarea,button,form,details'.split(','), function(value) {
BOOLEAN_ELEMENTS[value] = true;
});
var ALIASED_ATTR = {
'ngMinlength': 'minlength',
'ngMaxlength': 'maxlength',
'ngMin': 'min',
'ngMax': 'max',
'ngPattern': 'pattern'
};
function getBooleanAttrName(element, name) {
// check dom last since we will most likely fail on name
var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
// booleanAttr is here twice to minimize DOM access
return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
}
function getAliasedAttrName(name) {
return ALIASED_ATTR[name];
}
forEach({
data: jqLiteData,
removeData: jqLiteRemoveData,
hasData: jqLiteHasData
}, function(fn, name) {
JQLite[name] = fn;
});
forEach({
data: jqLiteData,
inheritedData: jqLiteInheritedData,
scope: function(element) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
return jqLite.data(element, '$scope') || jqLiteInheritedData(element.parentNode || element, ['$isolateScope', '$scope']);
},
isolateScope: function(element) {
// Can't use jqLiteData here directly so we stay compatible with jQuery!
return jqLite.data(element, '$isolateScope') || jqLite.data(element, '$isolateScopeNoTemplate');
},
controller: jqLiteController,
injector: function(element) {
return jqLiteInheritedData(element, '$injector');
},
removeAttr: function(element, name) {
element.removeAttribute(name);
},
hasClass: jqLiteHasClass,
css: function(element, name, value) {
name = camelCase(name);
if (isDefined(value)) {
element.style[name] = value;
} else {
return element.style[name];
}
},
attr: function(element, name, value) {
var nodeType = element.nodeType;
if (nodeType === NODE_TYPE_TEXT || nodeType === NODE_TYPE_ATTRIBUTE || nodeType === NODE_TYPE_COMMENT) {
return;
}
var lowercasedName = lowercase(name);
if (BOOLEAN_ATTR[lowercasedName]) {
if (isDefined(value)) {
if (!!value) {
element[name] = true;
element.setAttribute(name, lowercasedName);
} else {
element[name] = false;
element.removeAttribute(lowercasedName);
}
} else {
return (element[name] ||
(element.attributes.getNamedItem(name) || noop).specified)
? lowercasedName
: undefined;
}
} else if (isDefined(value)) {
element.setAttribute(name, value);
} else if (element.getAttribute) {
// the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
// some elements (e.g. Document) don't have get attribute, so return undefined
var ret = element.getAttribute(name, 2);
// normalize non-existing attributes to undefined (as jQuery)
return ret === null ? undefined : ret;
}
},
prop: function(element, name, value) {
if (isDefined(value)) {
element[name] = value;
} else {
return element[name];
}
},
text: (function() {
getText.$dv = '';
return getText;
function getText(element, value) {
if (isUndefined(value)) {
var nodeType = element.nodeType;
return (nodeType === NODE_TYPE_ELEMENT || nodeType === NODE_TYPE_TEXT) ? element.textContent : '';
}
element.textContent = value;
}
})(),
val: function(element, value) {
if (isUndefined(value)) {
if (element.multiple && nodeName_(element) === 'select') {
var result = [];
forEach(element.options, function(option) {
if (option.selected) {
result.push(option.value || option.text);
}
});
return result.length === 0 ? null : result;
}
return element.value;
}
element.value = value;
},
html: function(element, value) {
if (isUndefined(value)) {
return element.innerHTML;
}
jqLiteDealoc(element, true);
element.innerHTML = value;
},
empty: jqLiteEmpty
}, function(fn, name) {
/**
* Properties: writes return selection, reads return first value
*/
JQLite.prototype[name] = function(arg1, arg2) {
var i, key;
var nodeCount = this.length;
// jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
// in a way that survives minification.
// jqLiteEmpty takes no arguments but is a setter.
if (fn !== jqLiteEmpty &&
(isUndefined((fn.length == 2 && (fn !== jqLiteHasClass && fn !== jqLiteController)) ? arg1 : arg2))) {
if (isObject(arg1)) {
// we are a write, but the object properties are the key/values
for (i = 0; i < nodeCount; i++) {
if (fn === jqLiteData) {
// data() takes the whole object in jQuery
fn(this[i], arg1);
} else {
for (key in arg1) {
fn(this[i], key, arg1[key]);
}
}
}
// return self for chaining
return this;
} else {
// we are a read, so read the first child.
// TODO: do we still need this?
var value = fn.$dv;
// Only if we have $dv do we iterate over all, otherwise it is just the first element.
var jj = (isUndefined(value)) ? Math.min(nodeCount, 1) : nodeCount;
for (var j = 0; j < jj; j++) {
var nodeValue = fn(this[j], arg1, arg2);
value = value ? value + nodeValue : nodeValue;
}
return value;
}
} else {
// we are a write, so apply to all children
for (i = 0; i < nodeCount; i++) {
fn(this[i], arg1, arg2);
}
// return self for chaining
return this;
}
};
});
function createEventHandler(element, events) {
var eventHandler = function(event, type) {
// jQuery specific api
event.isDefaultPrevented = function() {
return event.defaultPrevented;
};
var eventFns = events[type || event.type];
var eventFnsLength = eventFns ? eventFns.length : 0;
if (!eventFnsLength) return;
if (isUndefined(event.immediatePropagationStopped)) {
var originalStopImmediatePropagation = event.stopImmediatePropagation;
event.stopImmediatePropagation = function() {
event.immediatePropagationStopped = true;
if (event.stopPropagation) {
event.stopPropagation();
}
if (originalStopImmediatePropagation) {
originalStopImmediatePropagation.call(event);
}
};
}
event.isImmediatePropagationStopped = function() {
return event.immediatePropagationStopped === true;
};
// Some events have special handlers that wrap the real handler
var handlerWrapper = eventFns.specialHandlerWrapper || defaultHandlerWrapper;
// Copy event handlers in case event handlers array is modified during execution.
if ((eventFnsLength > 1)) {
eventFns = shallowCopy(eventFns);
}
for (var i = 0; i < eventFnsLength; i++) {
if (!event.isImmediatePropagationStopped()) {
handlerWrapper(element, event, eventFns[i]);
}
}
};
// TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
// events on `element`
eventHandler.elem = element;
return eventHandler;
}
function defaultHandlerWrapper(element, event, handler) {
handler.call(element, event);
}
function specialMouseHandlerWrapper(target, event, handler) {
// Refer to jQuery's implementation of mouseenter & mouseleave
// Read about mouseenter and mouseleave:
// http://www.quirksmode.org/js/events_mouse.html#link8
var related = event.relatedTarget;
// For mousenter/leave call the handler if related is outside the target.
// NB: No relatedTarget if the mouse left/entered the browser window
if (!related || (related !== target && !jqLiteContains.call(target, related))) {
handler.call(target, event);
}
}
//////////////////////////////////////////
// Functions iterating traversal.
// These functions chain results into a single
// selector.
//////////////////////////////////////////
forEach({
removeData: jqLiteRemoveData,
on: function jqLiteOn(element, type, fn, unsupported) {
if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');
// Do not add event handlers to non-elements because they will not be cleaned up.
if (!jqLiteAcceptsData(element)) {
return;
}
var expandoStore = jqLiteExpandoStore(element, true);
var events = expandoStore.events;
var handle = expandoStore.handle;
if (!handle) {
handle = expandoStore.handle = createEventHandler(element, events);
}
// http://jsperf.com/string-indexof-vs-split
var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type];
var i = types.length;
var addHandler = function(type, specialHandlerWrapper, noEventListener) {
var eventFns = events[type];
if (!eventFns) {
eventFns = events[type] = [];
eventFns.specialHandlerWrapper = specialHandlerWrapper;
if (type !== '$destroy' && !noEventListener) {
addEventListenerFn(element, type, handle);
}
}
eventFns.push(fn);
};
while (i--) {
type = types[i];
if (MOUSE_EVENT_MAP[type]) {
addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
addHandler(type, undefined, true);
} else {
addHandler(type);
}
}
},
off: jqLiteOff,
one: function(element, type, fn) {
element = jqLite(element);
//add the listener twice so that when it is called
//you can remove the original function and still be
//able to call element.off(ev, fn) normally
element.on(type, function onFn() {
element.off(type, fn);
element.off(type, onFn);
});
element.on(type, fn);
},
replaceWith: function(element, replaceNode) {
var index, parent = element.parentNode;
jqLiteDealoc(element);
forEach(new JQLite(replaceNode), function(node) {
if (index) {
parent.insertBefore(node, index.nextSibling);
} else {
parent.replaceChild(node, element);
}
index = node;
});
},
children: function(element) {
var children = [];
forEach(element.childNodes, function(element) {
if (element.nodeType === NODE_TYPE_ELEMENT) {
children.push(element);
}
});
return children;
},
contents: function(element) {
return element.contentDocument || element.childNodes || [];
},
append: function(element, node) {
var nodeType = element.nodeType;
if (nodeType !== NODE_TYPE_ELEMENT && nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT) return;
node = new JQLite(node);
for (var i = 0, ii = node.length; i < ii; i++) {
var child = node[i];
element.appendChild(child);
}
},
prepend: function(element, node) {
if (element.nodeType === NODE_TYPE_ELEMENT) {
var index = element.firstChild;
forEach(new JQLite(node), function(child) {
element.insertBefore(child, index);
});
}
},
wrap: function(element, wrapNode) {
wrapNode = jqLite(wrapNode).eq(0).clone()[0];
var parent = element.parentNode;
if (parent) {
parent.replaceChild(wrapNode, element);
}
wrapNode.appendChild(element);
},
remove: jqLiteRemove,
detach: function(element) {
jqLiteRemove(element, true);
},
after: function(element, newElement) {
var index = element, parent = element.parentNode;
newElement = new JQLite(newElement);
for (var i = 0, ii = newElement.length; i < ii; i++) {
var node = newElement[i];
parent.insertBefore(node, index.nextSibling);
index = node;
}
},
addClass: jqLiteAddClass,
removeClass: jqLiteRemoveClass,
toggleClass: function(element, selector, condition) {
if (selector) {
forEach(selector.split(' '), function(className) {
var classCondition = condition;
if (isUndefined(classCondition)) {
classCondition = !jqLiteHasClass(element, className);
}
(classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className);
});
}
},
parent: function(element) {
var parent = element.parentNode;
return parent && parent.nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT ? parent : null;
},
next: function(element) {
return element.nextElementSibling;
},
find: function(element, selector) {
if (element.getElementsByTagName) {
return element.getElementsByTagName(selector);
} else {
return [];
}
},
clone: jqLiteClone,
triggerHandler: function(element, event, extraParameters) {
var dummyEvent, eventFnsCopy, handlerArgs;
var eventName = event.type || event;
var expandoStore = jqLiteExpandoStore(element);
var events = expandoStore && expandoStore.events;
var eventFns = events && events[eventName];
if (eventFns) {
// Create a dummy event to pass to the handlers
dummyEvent = {
preventDefault: function() { this.defaultPrevented = true; },
isDefaultPrevented: function() { return this.defaultPrevented === true; },
stopImmediatePropagation: function() { this.immediatePropagationStopped = true; },
isImmediatePropagationStopped: function() { return this.immediatePropagationStopped === true; },
stopPropagation: noop,
type: eventName,
target: element
};
// If a custom event was provided then extend our dummy event with it
if (event.type) {
dummyEvent = extend(dummyEvent, event);
}
// Copy event handlers in case event handlers array is modified during execution.
eventFnsCopy = shallowCopy(eventFns);
handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];
forEach(eventFnsCopy, function(fn) {
if (!dummyEvent.isImmediatePropagationStopped()) {
fn.apply(element, handlerArgs);
}
});
}
}
}, function(fn, name) {
/**
* chaining functions
*/
JQLite.prototype[name] = function(arg1, arg2, arg3) {
var value;
for (var i = 0, ii = this.length; i < ii; i++) {
if (isUndefined(value)) {
value = fn(this[i], arg1, arg2, arg3);
if (isDefined(value)) {
// any function which returns a value needs to be wrapped
value = jqLite(value);
}
} else {
jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
}
}
return isDefined(value) ? value : this;
};
// bind legacy bind/unbind to on/off
JQLite.prototype.bind = JQLite.prototype.on;
JQLite.prototype.unbind = JQLite.prototype.off;
});
// Provider for private $$jqLite service
function $$jqLiteProvider() {
this.$get = function $$jqLite() {
return extend(JQLite, {
hasClass: function(node, classes) {
if (node.attr) node = node[0];
return jqLiteHasClass(node, classes);
},
addClass: function(node, classes) {
if (node.attr) node = node[0];
return jqLiteAddClass(node, classes);
},
removeClass: function(node, classes) {
if (node.attr) node = node[0];
return jqLiteRemoveClass(node, classes);
}
});
};
}
/**
* Computes a hash of an 'obj'.
* Hash of a:
* string is string
* number is number as string
* object is either result of calling $$hashKey function on the object or uniquely generated id,
* that is also assigned to the $$hashKey property of the object.
*
* @param obj
* @returns {string} hash string such that the same input will have the same hash string.
* The resulting string key is in 'type:hashKey' format.
*/
function hashKey(obj, nextUidFn) {
var key = obj && obj.$$hashKey;
if (key) {
if (typeof key === 'function') {
key = obj.$$hashKey();
}
return key;
}
var objType = typeof obj;
if (objType == 'function' || (objType == 'object' && obj !== null)) {
key = obj.$$hashKey = objType + ':' + (nextUidFn || nextUid)();
} else {
key = objType + ':' + obj;
}
return key;
}
/**
* HashMap which can use objects as keys
*/
function HashMap(array, isolatedUid) {
if (isolatedUid) {
var uid = 0;
this.nextUid = function() {
return ++uid;
};
}
forEach(array, this.put, this);
}
HashMap.prototype = {
/**
* Store key value pair
* @param key key to store can be any type
* @param value value to store can be any type
*/
put: function(key, value) {
this[hashKey(key, this.nextUid)] = value;
},
/**
* @param key
* @returns {Object} the value for the key
*/
get: function(key) {
return this[hashKey(key, this.nextUid)];
},
/**
* Remove the key/value pair
* @param key
*/
remove: function(key) {
var value = this[key = hashKey(key, this.nextUid)];
delete this[key];
return value;
}
};
var $$HashMapProvider = [function() {
this.$get = [function() {
return HashMap;
}];
}];
/**
* @ngdoc function
* @module ng
* @name angular.injector
* @kind function
*
* @description
* Creates an injector object that can be used for retrieving services as well as for
* dependency injection (see {@link guide/di dependency injection}).
*
* @param {Array.<string|Function>} modules A list of module functions or their aliases. See
* {@link angular.module}. The `ng` module must be explicitly added.
* @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which
* disallows argument name annotation inference.
* @returns {injector} Injector object. See {@link auto.$injector $injector}.
*
* @example
* Typical usage
* ```js
* // create an injector
* var $injector = angular.injector(['ng']);
*
* // use the injector to kick off your application
* // use the type inference to auto inject arguments, or use implicit injection
* $injector.invoke(function($rootScope, $compile, $document) {
* $compile($document)($rootScope);
* $rootScope.$digest();
* });
* ```
*
* Sometimes you want to get access to the injector of a currently running Angular app
* from outside Angular. Perhaps, you want to inject and compile some markup after the
* application has been bootstrapped. You can do this using the extra `injector()` added
* to JQuery/jqLite elements. See {@link angular.element}.
*
* *This is fairly rare but could be the case if a third party library is injecting the
* markup.*
*
* In the following example a new block of HTML containing a `ng-controller`
* directive is added to the end of the document body by JQuery. We then compile and link
* it into the current AngularJS scope.
*
* ```js
* var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
* $(document.body).append($div);
*
* angular.element(document).injector().invoke(function($compile) {
* var scope = angular.element($div).scope();
* $compile($div)(scope);
* });
* ```
*/
/**
* @ngdoc module
* @name auto
* @description
*
* Implicit module which gets automatically added to each {@link auto.$injector $injector}.
*/
var FN_ARGS = /^[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var $injectorMinErr = minErr('$injector');
function anonFn(fn) {
// For anonymous functions, showing at the very least the function signature can help in
// debugging.
var fnText = fn.toString().replace(STRIP_COMMENTS, ''),
args = fnText.match(FN_ARGS);
if (args) {
return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')';
}
return 'fn';
}
function annotate(fn, strictDi, name) {
var $inject,
fnText,
argDecl,
last;
if (typeof fn === 'function') {
if (!($inject = fn.$inject)) {
$inject = [];
if (fn.length) {
if (strictDi) {
if (!isString(name) || !name) {
name = fn.name || anonFn(fn);
}
throw $injectorMinErr('strictdi',
'{0} is not using explicit annotation and cannot be invoked in strict mode', name);
}
fnText = fn.toString().replace(STRIP_COMMENTS, '');
argDecl = fnText.match(FN_ARGS);
forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) {
arg.replace(FN_ARG, function(all, underscore, name) {
$inject.push(name);
});
});
}
fn.$inject = $inject;
}
} else if (isArray(fn)) {
last = fn.length - 1;
assertArgFn(fn[last], 'fn');
$inject = fn.slice(0, last);
} else {
assertArgFn(fn, 'fn', true);
}
return $inject;
}
///////////////////////////////////////
/**
* @ngdoc service
* @name $injector
*
* @description
*
* `$injector` is used to retrieve object instances as defined by
* {@link auto.$provide provider}, instantiate types, invoke methods,
* and load modules.
*
* The following always holds true:
*
* ```js
* var $injector = angular.injector();
* expect($injector.get('$injector')).toBe($injector);
* expect($injector.invoke(function($injector) {
* return $injector;
* })).toBe($injector);
* ```
*
* # Injection Function Annotation
*
* JavaScript does not have annotations, and annotations are needed for dependency injection. The
* following are all valid ways of annotating function with injection arguments and are equivalent.
*
* ```js
* // inferred (only works if code not minified/obfuscated)
* $injector.invoke(function(serviceA){});
*
* // annotated
* function explicit(serviceA) {};
* explicit.$inject = ['serviceA'];
* $injector.invoke(explicit);
*
* // inline
* $injector.invoke(['serviceA', function(serviceA){}]);
* ```
*
* ## Inference
*
* In JavaScript calling `toString()` on a function returns the function definition. The definition
* can then be parsed and the function arguments can be extracted. This method of discovering
* annotations is disallowed when the injector is in strict mode.
* *NOTE:* This does not work with minification, and obfuscation tools since these tools change the
* argument names.
*
* ## `$inject` Annotation
* By adding an `$inject` property onto a function the injection parameters can be specified.
*
* ## Inline
* As an array of injection names, where the last item in the array is the function to call.
*/
/**
* @ngdoc method
* @name $injector#get
*
* @description
* Return an instance of the service.
*
* @param {string} name The name of the instance to retrieve.
* @param {string=} caller An optional string to provide the origin of the function call for error messages.
* @return {*} The instance.
*/
/**
* @ngdoc method
* @name $injector#invoke
*
* @description
* Invoke the method and supply the method arguments from the `$injector`.
*
* @param {Function|Array.<string|Function>} fn The injectable function to invoke. Function parameters are
* injected according to the {@link guide/di $inject Annotation} rules.
* @param {Object=} self The `this` for the invoked method.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {*} the value returned by the invoked `fn` function.
*/
/**
* @ngdoc method
* @name $injector#has
*
* @description
* Allows the user to query if the particular service exists.
*
* @param {string} name Name of the service to query.
* @returns {boolean} `true` if injector has given service.
*/
/**
* @ngdoc method
* @name $injector#instantiate
* @description
* Create a new instance of JS type. The method takes a constructor function, invokes the new
* operator, and supplies all of the arguments to the constructor function as specified by the
* constructor annotation.
*
* @param {Function} Type Annotated constructor function.
* @param {Object=} locals Optional object. If preset then any argument names are read from this
* object first, before the `$injector` is consulted.
* @returns {Object} new instance of `Type`.
*/
/**
* @ngdoc method
* @name $injector#annotate
*
* @description
* Returns an array of service names which the function is requesting for injection. This API is
* used by the injector to determine which services need to be injected into the function when the
* function is invoked. There are three ways in which the function can be annotated with the needed
* dependencies.
*
* # Argument names
*
* The simplest form is to extract the dependencies from the arguments of the function. This is done
* by converting the function into a string using `toString()` method and extracting the argument
* names.
* ```js
* // Given
* function MyController($scope, $route) {
* // ...
* }
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* ```
*
* You can disallow this method by using strict injection mode.
*
* This method does not work with code minification / obfuscation. For this reason the following
* annotation strategies are supported.
*
* # The `$inject` property
*
* If a function has an `$inject` property and its value is an array of strings, then the strings
* represent names of services to be injected into the function.
* ```js
* // Given
* var MyController = function(obfuscatedScope, obfuscatedRoute) {
* // ...
* }
* // Define function dependencies
* MyController['$inject'] = ['$scope', '$route'];
*
* // Then
* expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* ```
*
* # The array notation
*
* It is often desirable to inline Injected functions and that's when setting the `$inject` property
* is very inconvenient. In these situations using the array notation to specify the dependencies in
* a way that survives minification is a better choice:
*
* ```js
* // We wish to write this (not minification / obfuscation safe)
* injector.invoke(function($compile, $rootScope) {
* // ...
* });
*
* // We are forced to write break inlining
* var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
* // ...
* };
* tmpFn.$inject = ['$compile', '$rootScope'];
* injector.invoke(tmpFn);
*
* // To better support inline function the inline annotation is supported
* injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
* // ...
* }]);
*
* // Therefore
* expect(injector.annotate(
* ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
* ).toEqual(['$compile', '$rootScope']);
* ```
*
* @param {Function|Array.<string|Function>} fn Function for which dependent service names need to
* be retrieved as described above.
*
* @param {boolean=} [strictDi=false] Disallow argument name annotation inference.
*
* @returns {Array.<string>} The names of the services which the function requires.
*/
/**
* @ngdoc service
* @name $provide
*
* @description
*
* The {@link auto.$provide $provide} service has a number of methods for registering components
* with the {@link auto.$injector $injector}. Many of these functions are also exposed on
* {@link angular.Module}.
*
* An Angular **service** is a singleton object created by a **service factory**. These **service
* factories** are functions which, in turn, are created by a **service provider**.
* The **service providers** are constructor functions. When instantiated they must contain a
* property called `$get`, which holds the **service factory** function.
*
* When you request a service, the {@link auto.$injector $injector} is responsible for finding the
* correct **service provider**, instantiating it and then calling its `$get` **service factory**
* function to get the instance of the **service**.
*
* Often services have no configuration options and there is no need to add methods to the service
* provider. The provider will be no more than a constructor function with a `$get` property. For
* these cases the {@link auto.$provide $provide} service has additional helper methods to register
* services without specifying a provider.
*
* * {@link auto.$provide#provider provider(provider)} - registers a **service provider** with the
* {@link auto.$injector $injector}
* * {@link auto.$provide#constant constant(obj)} - registers a value/object that can be accessed by
* providers and services.
* * {@link auto.$provide#value value(obj)} - registers a value/object that can only be accessed by
* services, not providers.
* * {@link auto.$provide#factory factory(fn)} - registers a service **factory function**, `fn`,
* that will be wrapped in a **service provider** object, whose `$get` property will contain the
* given factory function.
* * {@link auto.$provide#service service(class)} - registers a **constructor function**, `class`
* that will be wrapped in a **service provider** object, whose `$get` property will instantiate
* a new object using the given constructor function.
*
* See the individual methods for more information and examples.
*/
/**
* @ngdoc method
* @name $provide#provider
* @description
*
* Register a **provider function** with the {@link auto.$injector $injector}. Provider functions
* are constructor functions, whose instances are responsible for "providing" a factory for a
* service.
*
* Service provider names start with the name of the service they provide followed by `Provider`.
* For example, the {@link ng.$log $log} service has a provider called
* {@link ng.$logProvider $logProvider}.
*
* Service provider objects can have additional methods which allow configuration of the provider
* and its service. Importantly, you can configure what kind of service is created by the `$get`
* method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
* method {@link ng.$logProvider#debugEnabled debugEnabled}
* which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
* console or not.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name +
'Provider'` key.
* @param {(Object|function())} provider If the provider is:
*
* - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
* {@link auto.$injector#invoke $injector.invoke()} when an instance needs to be created.
* - `Constructor`: a new instance of the provider will be created using
* {@link auto.$injector#instantiate $injector.instantiate()}, then treated as `object`.
*
* @returns {Object} registered provider instance
* @example
*
* The following example shows how to create a simple event tracking service and register it using
* {@link auto.$provide#provider $provide.provider()}.
*
* ```js
* // Define the eventTracker provider
* function EventTrackerProvider() {
* var trackingUrl = '/track';
*
* // A provider method for configuring where the tracked events should been saved
* this.setTrackingUrl = function(url) {
* trackingUrl = url;
* };
*
* // The service factory function
* this.$get = ['$http', function($http) {
* var trackedEvents = {};
* return {
* // Call this to track an event
* event: function(event) {
* var count = trackedEvents[event] || 0;
* count += 1;
* trackedEvents[event] = count;
* return count;
* },
* // Call this to save the tracked events to the trackingUrl
* save: function() {
* $http.post(trackingUrl, trackedEvents);
* }
* };
* }];
* }
*
* describe('eventTracker', function() {
* var postSpy;
*
* beforeEach(module(function($provide) {
* // Register the eventTracker provider
* $provide.provider('eventTracker', EventTrackerProvider);
* }));
*
* beforeEach(module(function(eventTrackerProvider) {
* // Configure eventTracker provider
* eventTrackerProvider.setTrackingUrl('/custom-track');
* }));
*
* it('tracks events', inject(function(eventTracker) {
* expect(eventTracker.event('login')).toEqual(1);
* expect(eventTracker.event('login')).toEqual(2);
* }));
*
* it('saves to the tracking url', inject(function(eventTracker, $http) {
* postSpy = spyOn($http, 'post');
* eventTracker.event('login');
* eventTracker.save();
* expect(postSpy).toHaveBeenCalled();
* expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
* expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
* expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
* }));
* });
* ```
*/
/**
* @ngdoc method
* @name $provide#factory
* @description
*
* Register a **service factory**, which will be called to return the service instance.
* This is short for registering a service where its provider consists of only a `$get` property,
* which is the given service factory function.
* You should use {@link auto.$provide#factory $provide.factory(getFn)} if you do not need to
* configure your service in a provider.
*
* @param {string} name The name of the instance.
* @param {Function|Array.<string|Function>} $getFn The injectable $getFn for the instance creation.
* Internally this is a short hand for `$provide.provider(name, {$get: $getFn})`.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service
* ```js
* $provide.factory('ping', ['$http', function($http) {
* return function ping() {
* return $http.send('/ping');
* };
* }]);
* ```
* You would then inject and use this service like this:
* ```js
* someModule.controller('Ctrl', ['ping', function(ping) {
* ping();
* }]);
* ```
*/
/**
* @ngdoc method
* @name $provide#service
* @description
*
* Register a **service constructor**, which will be invoked with `new` to create the service
* instance.
* This is short for registering a service where its provider's `$get` property is the service
* constructor function that will be used to instantiate the service instance.
*
* You should use {@link auto.$provide#service $provide.service(class)} if you define your service
* as a type/class.
*
* @param {string} name The name of the instance.
* @param {Function|Array.<string|Function>} constructor An injectable class (constructor function)
* that will be instantiated.
* @returns {Object} registered provider instance
*
* @example
* Here is an example of registering a service using
* {@link auto.$provide#service $provide.service(class)}.
* ```js
* var Ping = function($http) {
* this.$http = $http;
* };
*
* Ping.$inject = ['$http'];
*
* Ping.prototype.send = function() {
* return this.$http.get('/ping');
* };
* $provide.service('ping', Ping);
* ```
* You would then inject and use this service like this:
* ```js
* someModule.controller('Ctrl', ['ping', function(ping) {
* ping.send();
* }]);
* ```
*/
/**
* @ngdoc method
* @name $provide#value
* @description
*
* Register a **value service** with the {@link auto.$injector $injector}, such as a string, a
* number, an array, an object or a function. This is short for registering a service where its
* provider's `$get` property is a factory function that takes no arguments and returns the **value
* service**.
*
* Value services are similar to constant services, except that they cannot be injected into a
* module configuration function (see {@link angular.Module#config}) but they can be overridden by
* an Angular
* {@link auto.$provide#decorator decorator}.
*
* @param {string} name The name of the instance.
* @param {*} value The value.
* @returns {Object} registered provider instance
*
* @example
* Here are some examples of creating value services.
* ```js
* $provide.value('ADMIN_USER', 'admin');
*
* $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
*
* $provide.value('halfOf', function(value) {
* return value / 2;
* });
* ```
*/
/**
* @ngdoc method
* @name $provide#constant
* @description
*
* Register a **constant service**, such as a string, a number, an array, an object or a function,
* with the {@link auto.$injector $injector}. Unlike {@link auto.$provide#value value} it can be
* injected into a module configuration function (see {@link angular.Module#config}) and it cannot
* be overridden by an Angular {@link auto.$provide#decorator decorator}.
*
* @param {string} name The name of the constant.
* @param {*} value The constant value.
* @returns {Object} registered instance
*
* @example
* Here a some examples of creating constants:
* ```js
* $provide.constant('SHARD_HEIGHT', 306);
*
* $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
*
* $provide.constant('double', function(value) {
* return value * 2;
* });
* ```
*/
/**
* @ngdoc method
* @name $provide#decorator
* @description
*
* Register a **service decorator** with the {@link auto.$injector $injector}. A service decorator
* intercepts the creation of a service, allowing it to override or modify the behaviour of the
* service. The object returned by the decorator may be the original service, or a new service
* object which replaces or wraps and delegates to the original service.
*
* @param {string} name The name of the service to decorate.
* @param {Function|Array.<string|Function>} decorator This function will be invoked when the service needs to be
* instantiated and should return the decorated service instance. The function is called using
* the {@link auto.$injector#invoke injector.invoke} method and is therefore fully injectable.
* Local injection arguments:
*
* * `$delegate` - The original service instance, which can be monkey patched, configured,
* decorated or delegated to.
*
* @example
* Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
* calls to {@link ng.$log#error $log.warn()}.
* ```js
* $provide.decorator('$log', ['$delegate', function($delegate) {
* $delegate.warn = $delegate.error;
* return $delegate;
* }]);
* ```
*/
function createInjector(modulesToLoad, strictDi) {
strictDi = (strictDi === true);
var INSTANTIATING = {},
providerSuffix = 'Provider',
path = [],
loadedModules = new HashMap([], true),
providerCache = {
$provide: {
provider: supportObject(provider),
factory: supportObject(factory),
service: supportObject(service),
value: supportObject(value),
constant: supportObject(constant),
decorator: decorator
}
},
providerInjector = (providerCache.$injector =
createInternalInjector(providerCache, function(serviceName, caller) {
if (angular.isString(caller)) {
path.push(caller);
}
throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- '));
})),
instanceCache = {},
instanceInjector = (instanceCache.$injector =
createInternalInjector(instanceCache, function(serviceName, caller) {
var provider = providerInjector.get(serviceName + providerSuffix, caller);
return instanceInjector.invoke(provider.$get, provider, undefined, serviceName);
}));
forEach(loadModules(modulesToLoad), function(fn) { if (fn) instanceInjector.invoke(fn); });
return instanceInjector;
////////////////////////////////////
// $provider
////////////////////////////////////
function supportObject(delegate) {
return function(key, value) {
if (isObject(key)) {
forEach(key, reverseParams(delegate));
} else {
return delegate(key, value);
}
};
}
function provider(name, provider_) {
assertNotHasOwnProperty(name, 'service');
if (isFunction(provider_) || isArray(provider_)) {
provider_ = providerInjector.instantiate(provider_);
}
if (!provider_.$get) {
throw $injectorMinErr('pget', "Provider '{0}' must define $get factory method.", name);
}
return providerCache[name + providerSuffix] = provider_;
}
function enforceReturnValue(name, factory) {
return function enforcedReturnValue() {
var result = instanceInjector.invoke(factory, this);
if (isUndefined(result)) {
throw $injectorMinErr('undef', "Provider '{0}' must return a value from $get factory method.", name);
}
return result;
};
}
function factory(name, factoryFn, enforce) {
return provider(name, {
$get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
});
}
function service(name, constructor) {
return factory(name, ['$injector', function($injector) {
return $injector.instantiate(constructor);
}]);
}
function value(name, val) { return factory(name, valueFn(val), false); }
function constant(name, value) {
assertNotHasOwnProperty(name, 'constant');
providerCache[name] = value;
instanceCache[name] = value;
}
function decorator(serviceName, decorFn) {
var origProvider = providerInjector.get(serviceName + providerSuffix),
orig$get = origProvider.$get;
origProvider.$get = function() {
var origInstance = instanceInjector.invoke(orig$get, origProvider);
return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});
};
}
////////////////////////////////////
// Module Loading
////////////////////////////////////
function loadModules(modulesToLoad) {
assertArg(isUndefined(modulesToLoad) || isArray(modulesToLoad), 'modulesToLoad', 'not an array');
var runBlocks = [], moduleFn;
forEach(modulesToLoad, function(module) {
if (loadedModules.get(module)) return;
loadedModules.put(module, true);
function runInvokeQueue(queue) {
var i, ii;
for (i = 0, ii = queue.length; i < ii; i++) {
var invokeArgs = queue[i],
provider = providerInjector.get(invokeArgs[0]);
provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
}
}
try {
if (isString(module)) {
moduleFn = angularModule(module);
runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);
runInvokeQueue(moduleFn._invokeQueue);
runInvokeQueue(moduleFn._configBlocks);
} else if (isFunction(module)) {
runBlocks.push(providerInjector.invoke(module));
} else if (isArray(module)) {
runBlocks.push(providerInjector.invoke(module));
} else {
assertArgFn(module, 'module');
}
} catch (e) {
if (isArray(module)) {
module = module[module.length - 1];
}
if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {
// Safari & FF's stack traces don't contain error.message content
// unlike those of Chrome and IE
// So if stack doesn't contain message, we create a new string that contains both.
// Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
/* jshint -W022 */
e = e.message + '\n' + e.stack;
}
throw $injectorMinErr('modulerr', "Failed to instantiate module {0} due to:\n{1}",
module, e.stack || e.message || e);
}
});
return runBlocks;
}
////////////////////////////////////
// internal Injector
////////////////////////////////////
function createInternalInjector(cache, factory) {
function getService(serviceName, caller) {
if (cache.hasOwnProperty(serviceName)) {
if (cache[serviceName] === INSTANTIATING) {
throw $injectorMinErr('cdep', 'Circular dependency found: {0}',
serviceName + ' <- ' + path.join(' <- '));
}
return cache[serviceName];
} else {
try {
path.unshift(serviceName);
cache[serviceName] = INSTANTIATING;
return cache[serviceName] = factory(serviceName, caller);
} catch (err) {
if (cache[serviceName] === INSTANTIATING) {
delete cache[serviceName];
}
throw err;
} finally {
path.shift();
}
}
}
function invoke(fn, self, locals, serviceName) {
if (typeof locals === 'string') {
serviceName = locals;
locals = null;
}
var args = [],
$inject = createInjector.$$annotate(fn, strictDi, serviceName),
length, i,
key;
for (i = 0, length = $inject.length; i < length; i++) {
key = $inject[i];
if (typeof key !== 'string') {
throw $injectorMinErr('itkn',
'Incorrect injection token! Expected service name as string, got {0}', key);
}
args.push(
locals && locals.hasOwnProperty(key)
? locals[key]
: getService(key, serviceName)
);
}
if (isArray(fn)) {
fn = fn[length];
}
// http://jsperf.com/angularjs-invoke-apply-vs-switch
// #5388
return fn.apply(self, args);
}
function instantiate(Type, locals, serviceName) {
// Check if Type is annotated and use just the given function at n-1 as parameter
// e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
// Object creation: http://jsperf.com/create-constructor/2
var instance = Object.create((isArray(Type) ? Type[Type.length - 1] : Type).prototype || null);
var returnedValue = invoke(Type, instance, locals, serviceName);
return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance;
}
return {
invoke: invoke,
instantiate: instantiate,
get: getService,
annotate: createInjector.$$annotate,
has: function(name) {
return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);
}
};
}
}
createInjector.$$annotate = annotate;
/**
* @ngdoc provider
* @name $anchorScrollProvider
*
* @description
* Use `$anchorScrollProvider` to disable automatic scrolling whenever
* {@link ng.$location#hash $location.hash()} changes.
*/
function $AnchorScrollProvider() {
var autoScrollingEnabled = true;
/**
* @ngdoc method
* @name $anchorScrollProvider#disableAutoScrolling
*
* @description
* By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to
* {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.<br />
* Use this method to disable automatic scrolling.
*
* If automatic scrolling is disabled, one must explicitly call
* {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the
* current hash.
*/
this.disableAutoScrolling = function() {
autoScrollingEnabled = false;
};
/**
* @ngdoc service
* @name $anchorScroll
* @kind function
* @requires $window
* @requires $location
* @requires $rootScope
*
* @description
* When called, it scrolls to the element related to the specified `hash` or (if omitted) to the
* current value of {@link ng.$location#hash $location.hash()}, according to the rules specified
* in the
* [HTML5 spec](http://www.w3.org/html/wg/drafts/html/master/browsers.html#the-indicated-part-of-the-document).
*
* It also watches the {@link ng.$location#hash $location.hash()} and automatically scrolls to
* match any anchor whenever it changes. This can be disabled by calling
* {@link ng.$anchorScrollProvider#disableAutoScrolling $anchorScrollProvider.disableAutoScrolling()}.
*
* Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a
* vertical scroll-offset (either fixed or dynamic).
*
* @param {string=} hash The hash specifying the element to scroll to. If omitted, the value of
* {@link ng.$location#hash $location.hash()} will be used.
*
* @property {(number|function|jqLite)} yOffset
* If set, specifies a vertical scroll-offset. This is often useful when there are fixed
* positioned elements at the top of the page, such as navbars, headers etc.
*
* `yOffset` can be specified in various ways:
* - **number**: A fixed number of pixels to be used as offset.<br /><br />
* - **function**: A getter function called everytime `$anchorScroll()` is executed. Must return
* a number representing the offset (in pixels).<br /><br />
* - **jqLite**: A jqLite/jQuery element to be used for specifying the offset. The distance from
* the top of the page to the element's bottom will be used as offset.<br />
* **Note**: The element will be taken into account only as long as its `position` is set to
* `fixed`. This option is useful, when dealing with responsive navbars/headers that adjust
* their height and/or positioning according to the viewport's size.
*
* <br />
* <div class="alert alert-warning">
* In order for `yOffset` to work properly, scrolling should take place on the document's root and
* not some child element.
* </div>
*
* @example
<example module="anchorScrollExample">
<file name="index.html">
<div id="scrollArea" ng-controller="ScrollController">
<a ng-click="gotoBottom()">Go to bottom</a>
<a id="bottom"></a> You're at the bottom!
</div>
</file>
<file name="script.js">
angular.module('anchorScrollExample', [])
.controller('ScrollController', ['$scope', '$location', '$anchorScroll',
function ($scope, $location, $anchorScroll) {
$scope.gotoBottom = function() {
// set the location.hash to the id of
// the element you wish to scroll to.
$location.hash('bottom');
// call $anchorScroll()
$anchorScroll();
};
}]);
</file>
<file name="style.css">
#scrollArea {
height: 280px;
overflow: auto;
}
#bottom {
display: block;
margin-top: 2000px;
}
</file>
</example>
*
* <hr />
* The example below illustrates the use of a vertical scroll-offset (specified as a fixed value).
* See {@link ng.$anchorScroll#yOffset $anchorScroll.yOffset} for more details.
*
* @example
<example module="anchorScrollOffsetExample">
<file name="index.html">
<div class="fixed-header" ng-controller="headerCtrl">
<a href="" ng-click="gotoAnchor(x)" ng-repeat="x in [1,2,3,4,5]">
Go to anchor {{x}}
</a>
</div>
<div id="anchor{{x}}" class="anchor" ng-repeat="x in [1,2,3,4,5]">
Anchor {{x}} of 5
</div>
</file>
<file name="script.js">
angular.module('anchorScrollOffsetExample', [])
.run(['$anchorScroll', function($anchorScroll) {
$anchorScroll.yOffset = 50; // always scroll by 50 extra pixels
}])
.controller('headerCtrl', ['$anchorScroll', '$location', '$scope',
function ($anchorScroll, $location, $scope) {
$scope.gotoAnchor = function(x) {
var newHash = 'anchor' + x;
if ($location.hash() !== newHash) {
// set the $location.hash to `newHash` and
// $anchorScroll will automatically scroll to it
$location.hash('anchor' + x);
} else {
// call $anchorScroll() explicitly,
// since $location.hash hasn't changed
$anchorScroll();
}
};
}
]);
</file>
<file name="style.css">
body {
padding-top: 50px;
}
.anchor {
border: 2px dashed DarkOrchid;
padding: 10px 10px 200px 10px;
}
.fixed-header {
background-color: rgba(0, 0, 0, 0.2);
height: 50px;
position: fixed;
top: 0; left: 0; right: 0;
}
.fixed-header > a {
display: inline-block;
margin: 5px 15px;
}
</file>
</example>
*/
this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {
var document = $window.document;
// Helper function to get first anchor from a NodeList
// (using `Array#some()` instead of `angular#forEach()` since it's more performant
// and working in all supported browsers.)
function getFirstAnchor(list) {
var result = null;
Array.prototype.some.call(list, function(element) {
if (nodeName_(element) === 'a') {
result = element;
return true;
}
});
return result;
}
function getYOffset() {
var offset = scroll.yOffset;
if (isFunction(offset)) {
offset = offset();
} else if (isElement(offset)) {
var elem = offset[0];
var style = $window.getComputedStyle(elem);
if (style.position !== 'fixed') {
offset = 0;
} else {
offset = elem.getBoundingClientRect().bottom;
}
} else if (!isNumber(offset)) {
offset = 0;
}
return offset;
}
function scrollTo(elem) {
if (elem) {
elem.scrollIntoView();
var offset = getYOffset();
if (offset) {
// `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
// This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
// top of the viewport.
//
// IF the number of pixels from the top of `elem` to the end of the page's content is less
// than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
// way down the page.
//
// This is often the case for elements near the bottom of the page.
//
// In such cases we do not need to scroll the whole `offset`
gitextract_x5zzdzpb/ ├── .gitignore ├── Part1/ │ ├── .jshintrc │ ├── README.md │ ├── app/ │ │ ├── bundle.js │ │ ├── core/ │ │ │ ├── bootstrap.js │ │ │ └── vendor.js │ │ ├── index.html │ │ ├── index.js │ │ └── index.scss │ ├── package.json │ └── webpack.config.js ├── Part2/ │ ├── .jshintrc │ ├── README.md │ ├── app/ │ │ ├── bundle.js │ │ ├── core/ │ │ │ ├── bootstrap.js │ │ │ └── vendor.js │ │ ├── index.html │ │ ├── index.js │ │ └── index.scss │ ├── package.json │ └── webpack.config.js ├── Part3/ │ ├── .jshintrc │ ├── README.md │ ├── app/ │ │ ├── bundle.js │ │ ├── core/ │ │ │ ├── bootstrap.js │ │ │ ├── config/ │ │ │ │ └── production.js │ │ │ ├── layout.js │ │ │ ├── nav/ │ │ │ │ ├── nav.html │ │ │ │ ├── nav.js │ │ │ │ └── nav.scss │ │ │ └── vendor.js │ │ ├── index.html │ │ ├── index.js │ │ ├── index.json │ │ └── index.scss │ ├── package.json │ └── webpack.config.js └── README.md
SYMBOL INDEX (1215 symbols across 5 files)
FILE: Part1/app/bundle.js
function hotDownloadUpdateChunk (line 9) | function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unu...
function hotDownloadManifest (line 18) | function hotDownloadManifest(callback) { // eslint-disable-line no-unuse...
function hotCreateRequire (line 61) | function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
function hotCreateModule (line 110) | function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars
function hotSetStatus (line 176) | function hotSetStatus(newStatus) {
function toModuleId (line 193) | function toModuleId(id) {
function hotCheck (line 198) | function hotCheck(apply, callback) {
function hotAddUpdateChunk (line 239) | function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-lin...
function hotEnsureUpdateChunk (line 253) | function hotEnsureUpdateChunk(chunkId) {
function hotUpdateDownloaded (line 263) | function hotUpdateDownloaded() {
function hotApply (line 281) | function hotApply(options, callback) {
function __webpack_require__ (line 504) | function __webpack_require__(moduleId) {
function addStylesToDom (line 846) | function addStylesToDom(styles, options) {
function listToStyles (line 868) | function listToStyles(list) {
function insertStyleElement (line 886) | function insertStyleElement(options, styleElement) {
function removeStyleElement (line 905) | function removeStyleElement(styleElement) {
function createStyleElement (line 913) | function createStyleElement(options) {
function createLinkElement (line 920) | function createLinkElement(options) {
function addStyle (line 927) | function addStyle(obj, options) {
function applyToSingletonTag (line 978) | function applyToSingletonTag(styleElement, index, remove, obj) {
function applyToTag (line 995) | function applyToTag(styleElement, obj) {
function updateLink (line 1014) | function updateLink(linkElement, obj) {
function minErr (line 1084) | function minErr(module, ErrorConstructor) {
function isArrayLike (line 1315) | function isArrayLike(obj) {
function forEach (line 1371) | function forEach(obj, iterator, context) {
function forEachSorted (line 1415) | function forEachSorted(obj, iterator, context) {
function reverseParams (line 1429) | function reverseParams(iteratorFn) {
function nextUid (line 1443) | function nextUid() {
function setHashKey (line 1453) | function setHashKey(obj, h) {
function baseExtend (line 1462) | function baseExtend(dst, objs, deep) {
function extend (line 1514) | function extend(dst) {
function merge (line 1537) | function merge(dst) {
function toInt (line 1543) | function toInt(str) {
function inherit (line 1548) | function inherit(parent, extra) {
function noop (line 1568) | function noop() {}
function identity (line 1590) | function identity($) {return $;}
function valueFn (line 1594) | function valueFn(value) {return function() {return value;};}
function hasCustomToString (line 1596) | function hasCustomToString(obj) {
function isUndefined (line 1613) | function isUndefined(value) {return typeof value === 'undefined';}
function isDefined (line 1628) | function isDefined(value) {return typeof value !== 'undefined';}
function isObject (line 1644) | function isObject(value) {
function isBlankObject (line 1655) | function isBlankObject(value) {
function isString (line 1672) | function isString(value) {return typeof value === 'string';}
function isNumber (line 1693) | function isNumber(value) {return typeof value === 'number';}
function isDate (line 1708) | function isDate(value) {
function isFunction (line 1739) | function isFunction(value) {return typeof value === 'function';}
function isRegExp (line 1749) | function isRegExp(value) {
function isWindow (line 1761) | function isWindow(obj) {
function isScope (line 1766) | function isScope(obj) {
function isFile (line 1771) | function isFile(obj) {
function isFormData (line 1776) | function isFormData(obj) {
function isBlob (line 1781) | function isBlob(obj) {
function isBoolean (line 1786) | function isBoolean(value) {
function isPromiseLike (line 1791) | function isPromiseLike(obj) {
function isTypedArray (line 1797) | function isTypedArray(value) {
function isElement (line 1827) | function isElement(node) {
function makeMap (line 1837) | function makeMap(str) {
function nodeName_ (line 1846) | function nodeName_(element) {
function includes (line 1850) | function includes(array, obj) {
function arrayRemove (line 1854) | function arrayRemove(array, value) {
function copy (line 1920) | function copy(source, destination) {
function shallowCopy (line 2032) | function shallowCopy(src, dst) {
function equals (line 2082) | function equals(o1, o2) {
function noUnsafeEval (line 2148) | function noUnsafeEval() {
function concat (line 2213) | function concat(array1, array2, index) {
function sliceArgs (line 2217) | function sliceArgs(args, startIndex) {
function bind (line 2241) | function bind(self, fn) {
function toJsonReplacer (line 2262) | function toJsonReplacer(key, value) {
function toJson (line 2294) | function toJson(obj, pretty) {
function fromJson (line 2315) | function fromJson(json) {
function timezoneToOffset (line 2322) | function timezoneToOffset(timezone, fallback) {
function addDateMinutes (line 2328) | function addDateMinutes(date, minutes) {
function convertTimezoneToLocal (line 2335) | function convertTimezoneToLocal(date, timezone, reverse) {
function startingTag (line 2345) | function startingTag(element) {
function tryDecodeURIComponent (line 2375) | function tryDecodeURIComponent(value) {
function parseKeyValue (line 2388) | function parseKeyValue(/**string*/keyValue) {
function toKeyValue (line 2415) | function toKeyValue(obj) {
function encodeUriSegment (line 2443) | function encodeUriSegment(val) {
function encodeUriQuery (line 2462) | function encodeUriQuery(val, pctEncodeSpaces) {
function getNgAttribute (line 2474) | function getNgAttribute(element, ngAttr) {
function angularInit (line 2612) | function angularInit(element, bootstrap) {
function bootstrap (line 2691) | function bootstrap(element, modules, config) {
function reloadWithDebugInfo (line 2769) | function reloadWithDebugInfo() {
function getTestability (line 2782) | function getTestability(rootElement) {
function snake_case (line 2792) | function snake_case(name, separator) {
function bindJQuery (line 2801) | function bindJQuery() {
function assertArg (line 2859) | function assertArg(arg, name, reason) {
function assertArgFn (line 2866) | function assertArgFn(arg, name, acceptArrayAnnotation) {
function assertNotHasOwnProperty (line 2881) | function assertNotHasOwnProperty(name, context) {
function getter (line 2895) | function getter(obj, path, bindFnToScope) {
function getBlockNodes (line 2919) | function getBlockNodes(nodes) {
function createMap (line 2949) | function createMap() {
function setupModuleLoader (line 2969) | function setupModuleLoader(window) {
function serializeObject (line 3311) | function serializeObject(obj) {
function toDebugString (line 3326) | function toDebugString(obj) {
function publishExternalAPI (line 3455) | function publishExternalAPI(angular) {
function jqNextId (line 3722) | function jqNextId() { return ++jqId; }
function camelCase (line 3735) | function camelCase(name) {
function jqLiteIsTextNode (line 3763) | function jqLiteIsTextNode(html) {
function jqLiteAcceptsData (line 3767) | function jqLiteAcceptsData(node) {
function jqLiteHasData (line 3774) | function jqLiteHasData(node) {
function jqLiteBuildFragment (line 3781) | function jqLiteBuildFragment(html, context) {
function jqLiteParseHTML (line 3818) | function jqLiteParseHTML(html, context) {
function JQLite (line 3842) | function JQLite(element) {
function jqLiteClone (line 3867) | function jqLiteClone(element) {
function jqLiteDealoc (line 3871) | function jqLiteDealoc(element, onlyDescendants) {
function jqLiteOff (line 3882) | function jqLiteOff(element, type, fn, unsupported) {
function jqLiteRemoveData (line 3920) | function jqLiteRemoveData(element, name) {
function jqLiteExpandoStore (line 3942) | function jqLiteExpandoStore(element, createIfNecessary) {
function jqLiteData (line 3955) | function jqLiteData(element, key, value) {
function jqLiteHasClass (line 3981) | function jqLiteHasClass(element, selector) {
function jqLiteRemoveClass (line 3987) | function jqLiteRemoveClass(element, cssClasses) {
function jqLiteAddClass (line 3999) | function jqLiteAddClass(element, cssClasses) {
function jqLiteAddNodes (line 4016) | function jqLiteAddNodes(root, elements) {
function jqLiteController (line 4042) | function jqLiteController(element, name) {
function jqLiteInheritedData (line 4046) | function jqLiteInheritedData(element, name, value) {
function jqLiteEmpty (line 4066) | function jqLiteEmpty(element) {
function jqLiteRemove (line 4073) | function jqLiteRemove(element, keepData) {
function jqLiteDocumentLoaded (line 4080) | function jqLiteDocumentLoaded(action, win) {
function trigger (line 4100) | function trigger() {
function getBooleanAttrName (line 4154) | function getBooleanAttrName(element, name) {
function getAliasedAttrName (line 4162) | function getAliasedAttrName(name) {
function getText (line 4254) | function getText(element, value) {
function createEventHandler (line 4339) | function createEventHandler(element, events) {
function defaultHandlerWrapper (line 4391) | function defaultHandlerWrapper(element, event, handler) {
function specialMouseHandlerWrapper (line 4395) | function specialMouseHandlerWrapper(target, event, handler) {
function $$jqLiteProvider (line 4647) | function $$jqLiteProvider() {
function hashKey (line 4678) | function hashKey(obj, nextUidFn) {
function HashMap (line 4701) | function HashMap(array, isolatedUid) {
function anonFn (line 4813) | function anonFn(fn) {
function annotate (line 4824) | function annotate(fn, strictDi, name) {
function createInjector (line 5359) | function createInjector(modulesToLoad, strictDi) {
function $AnchorScrollProvider (line 5604) | function $AnchorScrollProvider() {
function mergeClasses (line 5871) | function mergeClasses(a,b) {
function extractElementNode (line 5880) | function extractElementNode(element) {
function splitClasses (line 5889) | function splitClasses(classes) {
function prepareAnimateOptions (line 5914) | function prepareAnimateOptions(options) {
function AnimateRunner (line 5922) | function AnimateRunner() {}
function updateData (line 5973) | function updateData(data, classes, value) {
function handleCSSClassChanges (line 5988) | function handleCSSClassChanges() {
function addRemoveClassesPostDigest (line 6017) | function addRemoveClassesPostDigest(element, add, remove) {
function domInsert (line 6131) | function domInsert(element, parentElement, afterElement) {
function run (line 6522) | function run() {
function close (line 6533) | function close() {
function Browser (line 6574) | function Browser(window, document, $log, $sniffer) {
function $BrowserProvider (line 6904) | function $BrowserProvider() {
function $CacheFactoryProvider (line 6992) | function $CacheFactoryProvider() {
function $TemplateCacheProvider (line 7307) | function $TemplateCacheProvider() {
function $CompileProvider (line 8056) | function $CompileProvider($provide, $$sanitizeUriProvider) {
function directiveNormalize (line 9996) | function directiveNormalize(name) {
function nodesetLinkingFn (line 10045) | function nodesetLinkingFn(
function directiveLinkingFn (line 10052) | function directiveLinkingFn(
function tokenDifference (line 10060) | function tokenDifference(str1, str2) {
function removeComments (line 10076) | function removeComments(jqNodes) {
function identifierForController (line 10097) | function identifierForController(controller, ident) {
function $ControllerProvider (line 10116) | function $ControllerProvider() {
function $DocumentProvider (line 10289) | function $DocumentProvider() {
function $ExceptionHandlerProvider (line 10335) | function $ExceptionHandlerProvider() {
function serializeValue (line 10381) | function serializeValue(v) {
function $HttpParamSerializerProvider (line 10389) | function $HttpParamSerializerProvider() {
function $HttpParamSerializerJQLikeProvider (line 10426) | function $HttpParamSerializerJQLikeProvider() {
function defaultHttpResponseTransform (line 10498) | function defaultHttpResponseTransform(data, headers) {
function isJsonLike (line 10514) | function isJsonLike(str) {
function parseHeaders (line 10525) | function parseHeaders(headers) {
function headersGetter (line 10561) | function headersGetter(headers) {
function transformData (line 10591) | function transformData(data, headers, status, fns) {
function isSuccess (line 10604) | function isSuccess(status) {
function $HttpProvider (line 10615) | function $HttpProvider() {
function $xhrFactoryProvider (line 11697) | function $xhrFactoryProvider() {
function $HttpBackendProvider (line 11722) | function $HttpBackendProvider() {
function createHttpBackend (line 11728) | function createHttpBackend($browser, createXhr, $browserDefer, callbacks...
function $InterpolateProvider (line 11922) | function $InterpolateProvider() {
function $IntervalProvider (line 12225) | function $IntervalProvider() {
function encodePath (line 12437) | function encodePath(path) {
function parseAbsoluteUrl (line 12448) | function parseAbsoluteUrl(absoluteUrl, locationObj) {
function parseAppUrl (line 12457) | function parseAppUrl(relativeUrl, locationObj) {
function beginsWith (line 12482) | function beginsWith(begin, whole) {
function stripHash (line 12489) | function stripHash(url) {
function trimEmptyHash (line 12494) | function trimEmptyHash(url) {
function stripFile (line 12499) | function stripFile(url) {
function serverBase (line 12504) | function serverBase(url) {
function LocationHtml5Url (line 12518) | function LocationHtml5Url(appBase, appBaseNoFile, basePrefix) {
function LocationHashbangUrl (line 12597) | function LocationHashbangUrl(appBase, appBaseNoFile, hashPrefix) {
function LocationHashbangInHtml5Url (line 12709) | function LocationHashbangInHtml5Url(appBase, appBaseNoFile, hashPrefix) {
function locationGetter (line 13073) | function locationGetter(property) {
function locationGetterSetter (line 13080) | function locationGetterSetter(property, preprocess) {
function $LocationProvider (line 13126) | function $LocationProvider() {
function $LogProvider (line 13460) | function $LogProvider() {
function ensureSafeMemberName (line 13616) | function ensureSafeMemberName(name, fullExpression) {
function getStringValue (line 13627) | function getStringValue(name, fullExpression) {
function ensureSafeObject (line 13646) | function ensureSafeObject(obj, fullExpression) {
function ensureSafeFunction (line 13677) | function ensureSafeFunction(obj, fullExpression) {
function ensureSafeAssignContext (line 13691) | function ensureSafeAssignContext(obj, fullExpression) {
function ifDefined (line 14208) | function ifDefined(v, d) {
function plusFn (line 14212) | function plusFn(l, r) {
function isStateless (line 14218) | function isStateless($filter, filterName) {
function findConstantAndWatchExpressions (line 14223) | function findConstantAndWatchExpressions(ast, $filter) {
function getInputs (line 14327) | function getInputs(body) {
function isAssignable (line 14335) | function isAssignable(ast) {
function assignableAST (line 14339) | function assignableAST(ast) {
function isLiteral (line 14345) | function isLiteral(ast) {
function isConstant (line 14353) | function isConstant(ast) {
function ASTCompiler (line 14357) | function ASTCompiler(astBuilder, $filter) {
function ASTInterpreter (line 14849) | function ASTInterpreter(astBuilder, $filter) {
function isPossiblyDangerousMemberName (line 15242) | function isPossiblyDangerousMemberName(name) {
function getValueOf (line 15248) | function getValueOf(value) {
function $ParseProvider (line 15303) | function $ParseProvider() {
function $QProvider (line 15735) | function $QProvider() {
function $$QProvider (line 15744) | function $$QProvider() {
function qFactory (line 15760) | function qFactory(nextTick, exceptionHandler) {
function $$RAFProvider (line 16114) | function $$RAFProvider() { //rAF
function $RootScopeProvider (line 16211) | function $RootScopeProvider() {
function $$SanitizeUriProvider (line 17512) | function $$SanitizeUriProvider() {
function adjustMatcher (line 17603) | function adjustMatcher(matcher) {
function adjustMatchers (line 17631) | function adjustMatchers(matchers) {
function $SceDelegateProvider (line 17709) | function $SceDelegateProvider() {
function $SceProvider (line 18239) | function $SceProvider() {
function $SnifferProvider (line 18651) | function $SnifferProvider() {
function $TemplateRequestProvider (line 18745) | function $TemplateRequestProvider() {
function $$TestabilityProvider (line 18798) | function $$TestabilityProvider() {
function $TimeoutProvider (line 18913) | function $TimeoutProvider() {
function urlResolve (line 19064) | function urlResolve(url) {
function urlIsSameOrigin (line 19098) | function urlIsSameOrigin(requestUrl) {
function $WindowProvider (line 19145) | function $WindowProvider() {
function $$CookieReader (line 19158) | function $$CookieReader($document) {
function $$CookieReaderProvider (line 19200) | function $$CookieReaderProvider() {
function $FilterProvider (line 19304) | function $FilterProvider($provide) {
function filterFilter (line 19494) | function filterFilter() {
function createPredicateFn (line 19531) | function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
function deepCompare (line 19568) | function deepCompare(actual, expected, comparator, matchAgainstAnyProp, ...
function getTypeForFilter (line 19618) | function getTypeForFilter(val) {
function currencyFilter (line 19675) | function currencyFilter($locale) {
function numberFilter (line 19749) | function numberFilter($locale) {
function formatNumber (line 19762) | function formatNumber(number, pattern, groupSep, decimalSep, fractionSiz...
function padNumber (line 19850) | function padNumber(num, digits, trim) {
function dateGetter (line 19865) | function dateGetter(name, size, offset, trim) {
function dateStrGetter (line 19877) | function dateStrGetter(name, shortForm) {
function timeZoneGetter (line 19886) | function timeZoneGetter(date, formats, offset) {
function getFirstThursdayOfYear (line 19896) | function getFirstThursdayOfYear(year) {
function getThursdayThisWeek (line 19904) | function getThursdayThisWeek(datetime) {
function weekGetter (line 19910) | function weekGetter(size) {
function ampmGetter (line 19922) | function ampmGetter(date, formats) {
function eraGetter (line 19926) | function eraGetter(date, formats) {
function longEraGetter (line 19930) | function longEraGetter(date, formats) {
function dateFilter (line 20064) | function dateFilter($locale) {
function jsonFilter (line 20171) | function jsonFilter() {
function limitToFilter (line 20300) | function limitToFilter() {
function orderByFilter (line 20501) | function orderByFilter($parse) {
function ngDirective (line 20619) | function ngDirective(directive) {
function defaultLinkFn (line 21021) | function defaultLinkFn(scope, element, attr) {
function nullFormRenameControl (line 21123) | function nullFormRenameControl(control, name) {
function FormController (line 21171) | function FormController(element, attrs, $scope, $animate, $interpolate) {
function getSetter (line 21649) | function getSetter(expression) {
function stringBasedInputType (line 22739) | function stringBasedInputType(ctrl) {
function textInputType (line 22745) | function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function baseInputType (line 22750) | function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function weekParser (line 22840) | function weekParser(isoWeek, existingDate) {
function createDateParser (line 22872) | function createDateParser(regexp, mapping) {
function createDateInputType (line 22922) | function createDateInputType(type, regexp, parseDate, format) {
function badInputChecker (line 22994) | function badInputChecker(scope, element, attr, ctrl) {
function numberInputType (line 23009) | function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function urlInputType (line 23063) | function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function emailInputType (line 23076) | function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function radioInputType (line 23089) | function radioInputType(scope, element, attr, ctrl) {
function parseConstantExpr (line 23111) | function parseConstantExpr($parse, context, name, expression, fallback) {
function checkboxInputType (line 23124) | function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browse...
function classDirective (line 23707) | function classDirective(name, selector) {
function processParseErrors (line 26258) | function processParseErrors() {
function processSyncValidators (line 26278) | function processSyncValidators() {
function processAsyncValidators (line 26294) | function processAsyncValidators() {
function setValidity (line 26320) | function setValidity(name, isValid) {
function validationDone (line 26326) | function validationDone(allValid) {
function writeToModelIfNeeded (line 26405) | function writeToModelIfNeeded() {
function addSetValidityMethod (line 26960) | function addSetValidityMethod(context) {
function isObjectEmpty (line 27054) | function isObjectEmpty(obj) {
function parseOptionsExpression (line 27346) | function parseOptionsExpression(optionsExp, selectElement, scope) {
function ngOptionsPostLink (line 27509) | function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
function updateElementText (line 28093) | function updateElementText(newText) {
function chromeHack (line 29353) | function chromeHack(optionElement) {
function selectPreLink (line 29711) | function selectPreLink(scope, element, attr, ctrls) {
function getDecimals (line 29932) | function getDecimals(n) {
function getVF (line 29938) | function getVF(n, opt_precision) {
function printMessage (line 30074) | function printMessage() {
FILE: Part1/app/index.js
function printMessage (line 5) | function printMessage (status='working') { // default params
FILE: Part2/app/bundle.js
function __webpack_require__ (line 6) | function __webpack_require__(moduleId) {
function printMessage (line 154) | function printMessage() {
function addStylesToDom (line 261) | function addStylesToDom(styles, options) {
function listToStyles (line 283) | function listToStyles(list) {
function createStyleElement (line 301) | function createStyleElement() {
function createLinkElement (line 309) | function createLinkElement() {
function addStyle (line 317) | function addStyle(obj, options) {
function replaceText (line 359) | function replaceText(source, id, replacement) {
function applyToSingletonTag (line 373) | function applyToSingletonTag(styleElement, index, remove, obj) {
function applyToTag (line 390) | function applyToTag(styleElement, obj) {
function updateLink (line 409) | function updateLink(linkElement, obj) {
function minErr (line 470) | function minErr(module, ErrorConstructor) {
function isArrayLike (line 690) | function isArrayLike(obj) {
function forEach (line 740) | function forEach(obj, iterator, context) {
function sortedKeys (line 771) | function sortedKeys(obj) {
function forEachSorted (line 775) | function forEachSorted(obj, iterator, context) {
function reverseParams (line 789) | function reverseParams(iteratorFn) {
function nextUid (line 803) | function nextUid() {
function setHashKey (line 813) | function setHashKey(obj, h) {
function extend (line 837) | function extend(dst) {
function int (line 855) | function int(str) {
function inherit (line 860) | function inherit(parent, extra) {
function noop (line 880) | function noop() {}
function identity (line 902) | function identity($) {return $;}
function valueFn (line 906) | function valueFn(value) {return function() {return value;};}
function isUndefined (line 920) | function isUndefined(value) {return typeof value === 'undefined';}
function isDefined (line 935) | function isDefined(value) {return typeof value !== 'undefined';}
function isObject (line 951) | function isObject(value) {
function isString (line 969) | function isString(value) {return typeof value === 'string';}
function isNumber (line 990) | function isNumber(value) {return typeof value === 'number';}
function isDate (line 1005) | function isDate(value) {
function isFunction (line 1036) | function isFunction(value) {return typeof value === 'function';}
function isRegExp (line 1046) | function isRegExp(value) {
function isWindow (line 1058) | function isWindow(obj) {
function isScope (line 1063) | function isScope(obj) {
function isFile (line 1068) | function isFile(obj) {
function isFormData (line 1073) | function isFormData(obj) {
function isBlob (line 1078) | function isBlob(obj) {
function isBoolean (line 1083) | function isBoolean(value) {
function isPromiseLike (line 1088) | function isPromiseLike(obj) {
function isElement (line 1118) | function isElement(node) {
function makeMap (line 1128) | function makeMap(str) {
function nodeName_ (line 1136) | function nodeName_(element) {
function includes (line 1140) | function includes(array, obj) {
function arrayRemove (line 1144) | function arrayRemove(array, value) {
function copy (line 1209) | function copy(source, destination, stackSource, stackDest) {
function shallowCopy (line 1287) | function shallowCopy(src, dst) {
function equals (line 1337) | function equals(o1, o2) {
function concat (line 1400) | function concat(array1, array2, index) {
function sliceArgs (line 1404) | function sliceArgs(args, startIndex) {
function bind (line 1428) | function bind(self, fn) {
function toJsonReplacer (line 1449) | function toJsonReplacer(key, value) {
function toJson (line 1481) | function toJson(obj, pretty) {
function fromJson (line 1502) | function fromJson(json) {
function startingTag (line 1512) | function startingTag(element) {
function tryDecodeURIComponent (line 1542) | function tryDecodeURIComponent(value) {
function parseKeyValue (line 1555) | function parseKeyValue(/**string*/keyValue) {
function toKeyValue (line 1576) | function toKeyValue(obj) {
function encodeUriSegment (line 1604) | function encodeUriSegment(val) {
function encodeUriQuery (line 1623) | function encodeUriQuery(val, pctEncodeSpaces) {
function getNgAttribute (line 1635) | function getNgAttribute(element, ngAttr) {
function angularInit (line 1774) | function angularInit(element, bootstrap) {
function bootstrap (line 1853) | function bootstrap(element, modules, config) {
function reloadWithDebugInfo (line 1931) | function reloadWithDebugInfo() {
function getTestability (line 1944) | function getTestability(rootElement) {
function snake_case (line 1954) | function snake_case(name, separator) {
function bindJQuery (line 1963) | function bindJQuery() {
function assertArg (line 2017) | function assertArg(arg, name, reason) {
function assertArgFn (line 2024) | function assertArgFn(arg, name, acceptArrayAnnotation) {
function assertNotHasOwnProperty (line 2039) | function assertNotHasOwnProperty(name, context) {
function getter (line 2053) | function getter(obj, path, bindFnToScope) {
function getBlockNodes (line 2077) | function getBlockNodes(nodes) {
function createMap (line 2105) | function createMap() {
function setupModuleLoader (line 2124) | function setupModuleLoader(window) {
function serializeObject (line 2434) | function serializeObject(obj) {
function toDebugString (line 2449) | function toDebugString(obj) {
function publishExternalAPI (line 2571) | function publishExternalAPI(angular) {
function jqNextId (line 2834) | function jqNextId() { return ++jqId; }
function camelCase (line 2847) | function camelCase(name) {
function jqLiteIsTextNode (line 2875) | function jqLiteIsTextNode(html) {
function jqLiteAcceptsData (line 2879) | function jqLiteAcceptsData(node) {
function jqLiteBuildFragment (line 2886) | function jqLiteBuildFragment(html, context) {
function jqLiteParseHTML (line 2923) | function jqLiteParseHTML(html, context) {
function JQLite (line 2939) | function JQLite(element) {
function jqLiteClone (line 2964) | function jqLiteClone(element) {
function jqLiteDealoc (line 2968) | function jqLiteDealoc(element, onlyDescendants) {
function jqLiteOff (line 2979) | function jqLiteOff(element, type, fn, unsupported) {
function jqLiteRemoveData (line 3011) | function jqLiteRemoveData(element, name) {
function jqLiteExpandoStore (line 3033) | function jqLiteExpandoStore(element, createIfNecessary) {
function jqLiteData (line 3046) | function jqLiteData(element, key, value) {
function jqLiteHasClass (line 3072) | function jqLiteHasClass(element, selector) {
function jqLiteRemoveClass (line 3078) | function jqLiteRemoveClass(element, cssClasses) {
function jqLiteAddClass (line 3090) | function jqLiteAddClass(element, cssClasses) {
function jqLiteAddNodes (line 3107) | function jqLiteAddNodes(root, elements) {
function jqLiteController (line 3133) | function jqLiteController(element, name) {
function jqLiteInheritedData (line 3137) | function jqLiteInheritedData(element, name, value) {
function jqLiteEmpty (line 3157) | function jqLiteEmpty(element) {
function jqLiteRemove (line 3164) | function jqLiteRemove(element, keepData) {
function jqLiteDocumentLoaded (line 3171) | function jqLiteDocumentLoaded(action, win) {
function trigger (line 3191) | function trigger() {
function getBooleanAttrName (line 3245) | function getBooleanAttrName(element, name) {
function getAliasedAttrName (line 3253) | function getAliasedAttrName(element, name) {
function getText (line 3341) | function getText(element, value) {
function createEventHandler (line 3426) | function createEventHandler(element, events) {
function $$jqLiteProvider (line 3721) | function $$jqLiteProvider() {
function hashKey (line 3752) | function hashKey(obj, nextUidFn) {
function HashMap (line 3775) | function HashMap(array, isolatedUid) {
function anonFn (line 3881) | function anonFn(fn) {
function annotate (line 3892) | function annotate(fn, strictDi, name) {
function createInjector (line 4426) | function createInjector(modulesToLoad, strictDi) {
function $AnchorScrollProvider (line 4670) | function $AnchorScrollProvider() {
function runAnimationPostDigest (line 5013) | function runAnimationPostDigest(fn) {
function resolveElementClasses (line 5028) | function resolveElementClasses(element, classes) {
function cachedClassManipulation (line 5054) | function cachedClassManipulation(cache, classes, op) {
function asyncPromise (line 5061) | function asyncPromise() {
function applyStyles (line 5073) | function applyStyles(element, options) {
function $$AsyncCallbackProvider (line 5299) | function $$AsyncCallbackProvider() {
function Browser (line 5332) | function Browser(window, document, $log, $sniffer) {
function $BrowserProvider (line 5773) | function $BrowserProvider() {
function $CacheFactoryProvider (line 5861) | function $CacheFactoryProvider() {
function $TemplateCacheProvider (line 6174) | function $TemplateCacheProvider() {
function $CompileProvider (line 6891) | function $CompileProvider($provide, $$sanitizeUriProvider) {
function directiveNormalize (line 8703) | function directiveNormalize(name) {
function nodesetLinkingFn (line 8752) | function nodesetLinkingFn(
function directiveLinkingFn (line 8759) | function directiveLinkingFn(
function tokenDifference (line 8767) | function tokenDifference(str1, str2) {
function removeComments (line 8783) | function removeComments(jqNodes) {
function $ControllerProvider (line 8812) | function $ControllerProvider() {
function $DocumentProvider (line 8979) | function $DocumentProvider() {
function $ExceptionHandlerProvider (line 9025) | function $ExceptionHandlerProvider() {
function defaultHttpResponseTransform (line 9042) | function defaultHttpResponseTransform(data, headers) {
function isJsonLike (line 9058) | function isJsonLike(str) {
function parseHeaders (line 9069) | function parseHeaders(headers) {
function headersGetter (line 9100) | function headersGetter(headers) {
function transformData (line 9130) | function transformData(data, headers, status, fns) {
function isSuccess (line 9142) | function isSuccess(status) {
function $HttpProvider (line 9153) | function $HttpProvider() {
function createXhr (line 10189) | function createXhr() {
function $HttpBackendProvider (line 10209) | function $HttpBackendProvider() {
function createHttpBackend (line 10215) | function createHttpBackend($browser, createXhr, $browserDefer, callbacks...
function $InterpolateProvider (line 10399) | function $InterpolateProvider() {
function $IntervalProvider (line 10709) | function $IntervalProvider() {
function $LocaleProvider (line 10904) | function $LocaleProvider() {
function encodePath (line 10985) | function encodePath(path) {
function parseAbsoluteUrl (line 10996) | function parseAbsoluteUrl(absoluteUrl, locationObj) {
function parseAppUrl (line 11005) | function parseAppUrl(relativeUrl, locationObj) {
function beginsWith (line 11030) | function beginsWith(begin, whole) {
function stripHash (line 11037) | function stripHash(url) {
function trimEmptyHash (line 11042) | function trimEmptyHash(url) {
function stripFile (line 11047) | function stripFile(url) {
function serverBase (line 11052) | function serverBase(url) {
function LocationHtml5Url (line 11065) | function LocationHtml5Url(appBase, basePrefix) {
function LocationHashbangUrl (line 11144) | function LocationHashbangUrl(appBase, hashPrefix) {
function LocationHashbangInHtml5Url (line 11248) | function LocationHashbangInHtml5Url(appBase, hashPrefix) {
function locationGetter (line 11604) | function locationGetter(property) {
function locationGetterSetter (line 11611) | function locationGetterSetter(property, preprocess) {
function $LocationProvider (line 11656) | function $LocationProvider() {
function $LogProvider (line 11981) | function $LogProvider() {
function ensureSafeMemberName (line 12137) | function ensureSafeMemberName(name, fullExpression) {
function ensureSafeObject (line 12148) | function ensureSafeObject(obj, fullExpression) {
function ensureSafeFunction (line 12179) | function ensureSafeFunction(obj, fullExpression) {
function isConstant (line 12425) | function isConstant(exp) {
function setter (line 12916) | function setter(obj, locals, path, setValue, fullExp) {
function isPossiblyDangerousMemberName (line 12939) | function isPossiblyDangerousMemberName(name) {
function cspSafeGetterFn (line 12948) | function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp, expensiv...
function getterFnWithEnsureSafeObject (line 12989) | function getterFnWithEnsureSafeObject(fn, fullExpression) {
function getterFn (line 12995) | function getterFn(path, options, fullExp) {
function getValueOf (line 13064) | function getValueOf(value) {
function $ParseProvider (line 13119) | function $ParseProvider() {
function $QProvider (line 13580) | function $QProvider() {
function $$QProvider (line 13589) | function $$QProvider() {
function qFactory (line 13605) | function qFactory(nextTick, exceptionHandler) {
function $$RAFProvider (line 13936) | function $$RAFProvider() { //rAF
function $RootScopeProvider (line 14033) | function $RootScopeProvider() {
function $$SanitizeUriProvider (line 15304) | function $$SanitizeUriProvider() {
function adjustMatcher (line 15395) | function adjustMatcher(matcher) {
function adjustMatchers (line 15423) | function adjustMatchers(matchers) {
function $SceDelegateProvider (line 15501) | function $SceDelegateProvider() {
function $SceProvider (line 16031) | function $SceProvider() {
function $SnifferProvider (line 16443) | function $SnifferProvider() {
function $TemplateRequestProvider (line 16535) | function $TemplateRequestProvider() {
function $$TestabilityProvider (line 16577) | function $$TestabilityProvider() {
function $TimeoutProvider (line 16692) | function $TimeoutProvider() {
function urlResolve (line 16838) | function urlResolve(url) {
function urlIsSameOrigin (line 16872) | function urlIsSameOrigin(requestUrl) {
function $WindowProvider (line 16919) | function $WindowProvider() {
function $FilterProvider (line 17016) | function $FilterProvider($provide) {
function filterFilter (line 17193) | function filterFilter() {
function createPredicateFn (line 17222) | function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
function deepCompare (line 17251) | function deepCompare(actual, expected, comparator, matchAgainstAnyProp, ...
function currencyFilter (line 17353) | function currencyFilter($locale) {
function numberFilter (line 17424) | function numberFilter($locale) {
function formatNumber (line 17437) | function formatNumber(number, pattern, groupSep, decimalSep, fractionSiz...
function padNumber (line 17518) | function padNumber(num, digits, trim) {
function dateGetter (line 17532) | function dateGetter(name, size, offset, trim) {
function dateStrGetter (line 17543) | function dateStrGetter(name, shortForm) {
function timeZoneGetter (line 17552) | function timeZoneGetter(date) {
function getFirstThursdayOfYear (line 17562) | function getFirstThursdayOfYear(year) {
function getThursdayThisWeek (line 17570) | function getThursdayThisWeek(datetime) {
function weekGetter (line 17576) | function weekGetter(size) {
function ampmGetter (line 17588) | function ampmGetter(date, formats) {
function eraGetter (line 17592) | function eraGetter(date, formats) {
function longEraGetter (line 17596) | function longEraGetter(date, formats) {
function dateFilter (line 17728) | function dateFilter($locale) {
function jsonFilter (line 17834) | function jsonFilter() {
function limitToFilter (line 17951) | function limitToFilter() {
function orderByFilter (line 18124) | function orderByFilter($parse) {
function ngDirective (line 18212) | function ngDirective(directive) {
function nullFormRenameControl (line 18697) | function nullFormRenameControl(control, name) {
function FormController (line 18744) | function FormController(element, attrs, $scope, $animate, $interpolate) {
function stringBasedInputType (line 20166) | function stringBasedInputType(ctrl) {
function textInputType (line 20172) | function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function baseInputType (line 20177) | function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function weekParser (line 20263) | function weekParser(isoWeek, existingDate) {
function createDateParser (line 20295) | function createDateParser(regexp, mapping) {
function createDateInputType (line 20345) | function createDateInputType(type, regexp, parseDate, format) {
function badInputChecker (line 20418) | function badInputChecker(scope, element, attr, ctrl) {
function numberInputType (line 20433) | function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function urlInputType (line 20487) | function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function emailInputType (line 20500) | function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function radioInputType (line 20513) | function radioInputType(scope, element, attr, ctrl) {
function parseConstantExpr (line 20535) | function parseConstantExpr($parse, context, name, expression, fallback) {
function checkboxInputType (line 20548) | function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browse...
function classDirective (line 21109) | function classDirective(name, selector) {
function processParseErrors (line 23587) | function processParseErrors() {
function processSyncValidators (line 23607) | function processSyncValidators() {
function processAsyncValidators (line 23623) | function processAsyncValidators() {
function setValidity (line 23649) | function setValidity(name, isValid) {
function validationDone (line 23655) | function validationDone(allValid) {
function writeToModelIfNeeded (line 23734) | function writeToModelIfNeeded() {
function addSetValidityMethod (line 24261) | function addSetValidityMethod(context) {
function isObjectEmpty (line 24356) | function isObjectEmpty(obj) {
function updateElementText (line 24620) | function updateElementText(newText) {
function setupAsSingle (line 26160) | function setupAsSingle(scope, selectElement, ngModelCtrl, selectCtrl) {
function setupAsMultiple (line 26185) | function setupAsMultiple(scope, selectElement, ctrl) {
function setupAsOptions (line 26216) | function setupAsOptions(scope, selectElement, ctrl) {
FILE: Part3/app/bundle.js
function hotDownloadUpdateChunk (line 9) | function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unu...
function hotDownloadManifest (line 18) | function hotDownloadManifest(callback) { // eslint-disable-line no-unuse...
function hotCreateRequire (line 61) | function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
function hotCreateModule (line 110) | function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars
function hotSetStatus (line 176) | function hotSetStatus(newStatus) {
function toModuleId (line 193) | function toModuleId(id) {
function hotCheck (line 198) | function hotCheck(apply, callback) {
function hotAddUpdateChunk (line 239) | function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-lin...
function hotEnsureUpdateChunk (line 253) | function hotEnsureUpdateChunk(chunkId) {
function hotUpdateDownloaded (line 263) | function hotUpdateDownloaded() {
function hotApply (line 281) | function hotApply(options, callback) {
function __webpack_require__ (line 504) | function __webpack_require__(moduleId) {
function addStylesToDom (line 857) | function addStylesToDom(styles, options) {
function listToStyles (line 879) | function listToStyles(list) {
function insertStyleElement (line 897) | function insertStyleElement(options, styleElement) {
function removeStyleElement (line 916) | function removeStyleElement(styleElement) {
function createStyleElement (line 924) | function createStyleElement(options) {
function createLinkElement (line 931) | function createLinkElement(options) {
function addStyle (line 938) | function addStyle(obj, options) {
function applyToSingletonTag (line 989) | function applyToSingletonTag(styleElement, index, remove, obj) {
function applyToTag (line 1006) | function applyToTag(styleElement, obj) {
function updateLink (line 1025) | function updateLink(linkElement, obj) {
function isArrayLike (line 1689) | function isArrayLike( obj ) {
function Sizzle (line 1898) | function Sizzle( selector, context, results, seed ) {
function createCache (line 2038) | function createCache() {
function markFunction (line 2056) | function markFunction( fn ) {
function assert (line 2065) | function assert( fn ) {
function addHandle (line 2087) | function addHandle( attrs, handler ) {
function siblingCheck (line 2102) | function siblingCheck( a, b ) {
function createInputPseudo (line 2129) | function createInputPseudo( type ) {
function createButtonPseudo (line 2140) | function createButtonPseudo( type ) {
function createPositionalPseudo (line 2151) | function createPositionalPseudo( fn ) {
function testContext (line 2174) | function testContext( context ) {
function setFilters (line 3219) | function setFilters() {}
function toSelector (line 3290) | function toSelector( tokens ) {
function addCombinator (line 3300) | function addCombinator( matcher, combinator, base ) {
function elementMatcher (line 3358) | function elementMatcher( matchers ) {
function multipleContexts (line 3372) | function multipleContexts( selector, contexts, results ) {
function condense (line 3381) | function condense( unmatched, map, filter, context, xml ) {
function setMatcher (line 3402) | function setMatcher( preFilter, selector, matcher, postFilter, postFinde...
function matcherFromTokens (line 3495) | function matcherFromTokens( tokens ) {
function matcherFromGroupMatchers (line 3553) | function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
function winnow (line 3891) | function winnow( elements, qualifier, not ) {
function sibling (line 4198) | function sibling( cur, dir ) {
function createOptions (line 4274) | function createOptions( options ) {
function completed (line 4709) | function completed() {
function Data (line 4820) | function Data() {
function dataAttr (line 5030) | function dataAttr( elem, key, data ) {
function adjustCSS (line 5347) | function adjustCSS( elem, prop, valueParts, tween ) {
function getAll (line 5436) | function getAll( context, tag ) {
function setGlobalEval (line 5453) | function setGlobalEval( elems, refElements ) {
function buildFragment (line 5469) | function buildFragment( elems, context, scripts, selection, ignored ) {
function returnTrue (line 5590) | function returnTrue() {
function returnFalse (line 5594) | function returnFalse() {
function safeActiveElement (line 5600) | function safeActiveElement() {
function on (line 5606) | function on( elem, types, selector, data, fn, one ) {
function manipulationTarget (line 6296) | function manipulationTarget( elem, content ) {
function disableScript (line 6307) | function disableScript( elem ) {
function restoreScript (line 6311) | function restoreScript( elem ) {
function cloneCopyEvent (line 6323) | function cloneCopyEvent( src, dest ) {
function fixInput (line 6358) | function fixInput( src, dest ) {
function domManip (line 6371) | function domManip( collection, args, callback, ignored ) {
function remove (line 6461) | function remove( elem, selector, keepData ) {
function actualDisplay (line 6752) | function actualDisplay( name, doc ) {
function defaultDisplay (line 6768) | function defaultDisplay( nodeName ) {
function computeStyleTests (line 6864) | function computeStyleTests() {
function curCSS (line 6954) | function curCSS( elem, name, computed ) {
function addGetHookIf (line 7001) | function addGetHookIf( conditionFn, hookFn ) {
function vendorPropName (line 7038) | function vendorPropName( name ) {
function setPositiveNumber (line 7057) | function setPositiveNumber( elem, value, subtract ) {
function augmentWidthOrHeight (line 7069) | function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
function getWidthOrHeight (line 7113) | function getWidthOrHeight( elem, name, extra ) {
function showHide (line 7171) | function showHide( elements, show ) {
function Tween (line 7510) | function Tween( elem, options, prop, end, easing ) {
function createFxNow (line 7634) | function createFxNow() {
function genFx (line 7642) | function genFx( type, includeWidth ) {
function createTween (line 7662) | function createTween( value, prop, animation ) {
function defaultPrefilter (line 7676) | function defaultPrefilter( elem, props, opts ) {
function propFilter (line 7812) | function propFilter( props, specialEasing ) {
function Animation (line 7849) | function Animation( elem, properties, options ) {
function getClass (line 8522) | function getClass( elem ) {
function addToPrefiltersOrTransports (line 9187) | function addToPrefiltersOrTransports( structure ) {
function inspectPrefiltersOrTransports (line 9221) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
function ajaxExtend (line 9250) | function ajaxExtend( target, src ) {
function ajaxHandleResponses (line 9270) | function ajaxHandleResponses( s, jqXHR, responses ) {
function ajaxConvert (line 9328) | function ajaxConvert( s, response, jqXHR, isSuccess ) {
function done (line 9833) | function done( status, nativeStatusText, responses, headers ) {
function buildParams (line 10086) | function buildParams( prefix, obj, traditional, add ) {
function getWindow (line 10669) | function getWindow( elem ) {
function isArraylike (line 11057) | function isArraylike (obj) {
function $makeArray (line 11242) | function $makeArray (arr, results) {
function offsetParent (line 11350) | function offsetParent() {
function compactSparseArray (line 11483) | function compactSparseArray (array) {
function sanitizeElements (line 11499) | function sanitizeElements (elements) {
function Data (line 11673) | function Data (element) {
function generateStep (line 11686) | function generateStep (steps) {
function generateBezier (line 11693) | function generateBezier (mX1, mY1, mX2, mY2) {
function springAccelerationForState (line 11821) | function springAccelerationForState (state) {
function springEvaluateStateWithDerivative (line 11825) | function springEvaluateStateWithDerivative (initialState, dt, derivative) {
function springIntegrateState (line 11836) | function springIntegrateState (state, dt) {
function getEasing (line 11945) | function getEasing(value, duration) {
function computePropertyValue (line 12616) | function computePropertyValue (element, property) {
function getTransformFloat (line 12887) | function getTransformFloat (transformProperty) {
function getChain (line 13008) | function getChain () {
function processElement (line 13368) | function processElement () {
function tick (line 14360) | function tick (timestamp) {
function completeCall (line 14615) | function completeCall (callIndex, isStopped) {
function minErr (line 14939) | function minErr(module, ErrorConstructor) {
function isArrayLike (line 15170) | function isArrayLike(obj) {
function forEach (line 15226) | function forEach(obj, iterator, context) {
function forEachSorted (line 15270) | function forEachSorted(obj, iterator, context) {
function reverseParams (line 15284) | function reverseParams(iteratorFn) {
function nextUid (line 15298) | function nextUid() {
function setHashKey (line 15308) | function setHashKey(obj, h) {
function baseExtend (line 15317) | function baseExtend(dst, objs, deep) {
function extend (line 15369) | function extend(dst) {
function merge (line 15392) | function merge(dst) {
function toInt (line 15398) | function toInt(str) {
function inherit (line 15403) | function inherit(parent, extra) {
function noop (line 15423) | function noop() {}
function identity (line 15445) | function identity($) {return $;}
function valueFn (line 15449) | function valueFn(value) {return function() {return value;};}
function hasCustomToString (line 15451) | function hasCustomToString(obj) {
function isUndefined (line 15468) | function isUndefined(value) {return typeof value === 'undefined';}
function isDefined (line 15483) | function isDefined(value) {return typeof value !== 'undefined';}
function isObject (line 15499) | function isObject(value) {
function isBlankObject (line 15510) | function isBlankObject(value) {
function isString (line 15527) | function isString(value) {return typeof value === 'string';}
function isNumber (line 15548) | function isNumber(value) {return typeof value === 'number';}
function isDate (line 15563) | function isDate(value) {
function isFunction (line 15594) | function isFunction(value) {return typeof value === 'function';}
function isRegExp (line 15604) | function isRegExp(value) {
function isWindow (line 15616) | function isWindow(obj) {
function isScope (line 15621) | function isScope(obj) {
function isFile (line 15626) | function isFile(obj) {
function isFormData (line 15631) | function isFormData(obj) {
function isBlob (line 15636) | function isBlob(obj) {
function isBoolean (line 15641) | function isBoolean(value) {
function isPromiseLike (line 15646) | function isPromiseLike(obj) {
function isTypedArray (line 15652) | function isTypedArray(value) {
function isElement (line 15682) | function isElement(node) {
function makeMap (line 15692) | function makeMap(str) {
function nodeName_ (line 15701) | function nodeName_(element) {
function includes (line 15705) | function includes(array, obj) {
function arrayRemove (line 15709) | function arrayRemove(array, value) {
function copy (line 15775) | function copy(source, destination) {
function shallowCopy (line 15887) | function shallowCopy(src, dst) {
function equals (line 15937) | function equals(o1, o2) {
function noUnsafeEval (line 16003) | function noUnsafeEval() {
function concat (line 16068) | function concat(array1, array2, index) {
function sliceArgs (line 16072) | function sliceArgs(args, startIndex) {
function bind (line 16096) | function bind(self, fn) {
function toJsonReplacer (line 16117) | function toJsonReplacer(key, value) {
function toJson (line 16149) | function toJson(obj, pretty) {
function fromJson (line 16170) | function fromJson(json) {
function timezoneToOffset (line 16177) | function timezoneToOffset(timezone, fallback) {
function addDateMinutes (line 16183) | function addDateMinutes(date, minutes) {
function convertTimezoneToLocal (line 16190) | function convertTimezoneToLocal(date, timezone, reverse) {
function startingTag (line 16200) | function startingTag(element) {
function tryDecodeURIComponent (line 16230) | function tryDecodeURIComponent(value) {
function parseKeyValue (line 16243) | function parseKeyValue(/**string*/keyValue) {
function toKeyValue (line 16270) | function toKeyValue(obj) {
function encodeUriSegment (line 16298) | function encodeUriSegment(val) {
function encodeUriQuery (line 16317) | function encodeUriQuery(val, pctEncodeSpaces) {
function getNgAttribute (line 16329) | function getNgAttribute(element, ngAttr) {
function angularInit (line 16467) | function angularInit(element, bootstrap) {
function bootstrap (line 16546) | function bootstrap(element, modules, config) {
function reloadWithDebugInfo (line 16624) | function reloadWithDebugInfo() {
function getTestability (line 16637) | function getTestability(rootElement) {
function snake_case (line 16647) | function snake_case(name, separator) {
function bindJQuery (line 16656) | function bindJQuery() {
function assertArg (line 16714) | function assertArg(arg, name, reason) {
function assertArgFn (line 16721) | function assertArgFn(arg, name, acceptArrayAnnotation) {
function assertNotHasOwnProperty (line 16736) | function assertNotHasOwnProperty(name, context) {
function getter (line 16750) | function getter(obj, path, bindFnToScope) {
function getBlockNodes (line 16774) | function getBlockNodes(nodes) {
function createMap (line 16804) | function createMap() {
function setupModuleLoader (line 16824) | function setupModuleLoader(window) {
function serializeObject (line 17166) | function serializeObject(obj) {
function toDebugString (line 17181) | function toDebugString(obj) {
function publishExternalAPI (line 17310) | function publishExternalAPI(angular) {
function jqNextId (line 17577) | function jqNextId() { return ++jqId; }
function camelCase (line 17590) | function camelCase(name) {
function jqLiteIsTextNode (line 17618) | function jqLiteIsTextNode(html) {
function jqLiteAcceptsData (line 17622) | function jqLiteAcceptsData(node) {
function jqLiteHasData (line 17629) | function jqLiteHasData(node) {
function jqLiteBuildFragment (line 17636) | function jqLiteBuildFragment(html, context) {
function jqLiteParseHTML (line 17673) | function jqLiteParseHTML(html, context) {
function JQLite (line 17697) | function JQLite(element) {
function jqLiteClone (line 17722) | function jqLiteClone(element) {
function jqLiteDealoc (line 17726) | function jqLiteDealoc(element, onlyDescendants) {
function jqLiteOff (line 17737) | function jqLiteOff(element, type, fn, unsupported) {
function jqLiteRemoveData (line 17775) | function jqLiteRemoveData(element, name) {
function jqLiteExpandoStore (line 17797) | function jqLiteExpandoStore(element, createIfNecessary) {
function jqLiteData (line 17810) | function jqLiteData(element, key, value) {
function jqLiteHasClass (line 17836) | function jqLiteHasClass(element, selector) {
function jqLiteRemoveClass (line 17842) | function jqLiteRemoveClass(element, cssClasses) {
function jqLiteAddClass (line 17854) | function jqLiteAddClass(element, cssClasses) {
function jqLiteAddNodes (line 17871) | function jqLiteAddNodes(root, elements) {
function jqLiteController (line 17897) | function jqLiteController(element, name) {
function jqLiteInheritedData (line 17901) | function jqLiteInheritedData(element, name, value) {
function jqLiteEmpty (line 17921) | function jqLiteEmpty(element) {
function jqLiteRemove (line 17928) | function jqLiteRemove(element, keepData) {
function jqLiteDocumentLoaded (line 17935) | function jqLiteDocumentLoaded(action, win) {
function trigger (line 17955) | function trigger() {
function getBooleanAttrName (line 18009) | function getBooleanAttrName(element, name) {
function getAliasedAttrName (line 18017) | function getAliasedAttrName(name) {
function getText (line 18109) | function getText(element, value) {
function createEventHandler (line 18194) | function createEventHandler(element, events) {
function defaultHandlerWrapper (line 18246) | function defaultHandlerWrapper(element, event, handler) {
function specialMouseHandlerWrapper (line 18250) | function specialMouseHandlerWrapper(target, event, handler) {
function $$jqLiteProvider (line 18502) | function $$jqLiteProvider() {
function hashKey (line 18533) | function hashKey(obj, nextUidFn) {
function HashMap (line 18556) | function HashMap(array, isolatedUid) {
function anonFn (line 18668) | function anonFn(fn) {
function annotate (line 18679) | function annotate(fn, strictDi, name) {
function createInjector (line 19214) | function createInjector(modulesToLoad, strictDi) {
function $AnchorScrollProvider (line 19459) | function $AnchorScrollProvider() {
function mergeClasses (line 19726) | function mergeClasses(a,b) {
function extractElementNode (line 19735) | function extractElementNode(element) {
function splitClasses (line 19744) | function splitClasses(classes) {
function prepareAnimateOptions (line 19769) | function prepareAnimateOptions(options) {
function AnimateRunner (line 19777) | function AnimateRunner() {}
function updateData (line 19828) | function updateData(data, classes, value) {
function handleCSSClassChanges (line 19843) | function handleCSSClassChanges() {
function addRemoveClassesPostDigest (line 19872) | function addRemoveClassesPostDigest(element, add, remove) {
function domInsert (line 19986) | function domInsert(element, parentElement, afterElement) {
function run (line 20377) | function run() {
function close (line 20388) | function close() {
function Browser (line 20429) | function Browser(window, document, $log, $sniffer) {
function $BrowserProvider (line 20759) | function $BrowserProvider() {
function $CacheFactoryProvider (line 20847) | function $CacheFactoryProvider() {
function $TemplateCacheProvider (line 21162) | function $TemplateCacheProvider() {
function $CompileProvider (line 21911) | function $CompileProvider($provide, $$sanitizeUriProvider) {
function directiveNormalize (line 23851) | function directiveNormalize(name) {
function nodesetLinkingFn (line 23900) | function nodesetLinkingFn(
function directiveLinkingFn (line 23907) | function directiveLinkingFn(
function tokenDifference (line 23915) | function tokenDifference(str1, str2) {
function removeComments (line 23931) | function removeComments(jqNodes) {
function identifierForController (line 23952) | function identifierForController(controller, ident) {
function $ControllerProvider (line 23971) | function $ControllerProvider() {
function $DocumentProvider (line 24144) | function $DocumentProvider() {
function $ExceptionHandlerProvider (line 24190) | function $ExceptionHandlerProvider() {
function serializeValue (line 24236) | function serializeValue(v) {
function $HttpParamSerializerProvider (line 24244) | function $HttpParamSerializerProvider() {
function $HttpParamSerializerJQLikeProvider (line 24281) | function $HttpParamSerializerJQLikeProvider() {
function defaultHttpResponseTransform (line 24353) | function defaultHttpResponseTransform(data, headers) {
function isJsonLike (line 24369) | function isJsonLike(str) {
function parseHeaders (line 24380) | function parseHeaders(headers) {
function headersGetter (line 24416) | function headersGetter(headers) {
function transformData (line 24446) | function transformData(data, headers, status, fns) {
function isSuccess (line 24459) | function isSuccess(status) {
function $HttpProvider (line 24470) | function $HttpProvider() {
function $xhrFactoryProvider (line 25552) | function $xhrFactoryProvider() {
function $HttpBackendProvider (line 25577) | function $HttpBackendProvider() {
function createHttpBackend (line 25583) | function createHttpBackend($browser, createXhr, $browserDefer, callbacks...
function $InterpolateProvider (line 25777) | function $InterpolateProvider() {
function $IntervalProvider (line 26080) | function $IntervalProvider() {
function encodePath (line 26292) | function encodePath(path) {
function parseAbsoluteUrl (line 26303) | function parseAbsoluteUrl(absoluteUrl, locationObj) {
function parseAppUrl (line 26312) | function parseAppUrl(relativeUrl, locationObj) {
function beginsWith (line 26337) | function beginsWith(begin, whole) {
function stripHash (line 26344) | function stripHash(url) {
function trimEmptyHash (line 26349) | function trimEmptyHash(url) {
function stripFile (line 26354) | function stripFile(url) {
function serverBase (line 26359) | function serverBase(url) {
function LocationHtml5Url (line 26373) | function LocationHtml5Url(appBase, appBaseNoFile, basePrefix) {
function LocationHashbangUrl (line 26452) | function LocationHashbangUrl(appBase, appBaseNoFile, hashPrefix) {
function LocationHashbangInHtml5Url (line 26564) | function LocationHashbangInHtml5Url(appBase, appBaseNoFile, hashPrefix) {
function locationGetter (line 26928) | function locationGetter(property) {
function locationGetterSetter (line 26935) | function locationGetterSetter(property, preprocess) {
function $LocationProvider (line 26981) | function $LocationProvider() {
function $LogProvider (line 27315) | function $LogProvider() {
function ensureSafeMemberName (line 27471) | function ensureSafeMemberName(name, fullExpression) {
function getStringValue (line 27482) | function getStringValue(name, fullExpression) {
function ensureSafeObject (line 27501) | function ensureSafeObject(obj, fullExpression) {
function ensureSafeFunction (line 27532) | function ensureSafeFunction(obj, fullExpression) {
function ensureSafeAssignContext (line 27546) | function ensureSafeAssignContext(obj, fullExpression) {
function ifDefined (line 28063) | function ifDefined(v, d) {
function plusFn (line 28067) | function plusFn(l, r) {
function isStateless (line 28073) | function isStateless($filter, filterName) {
function findConstantAndWatchExpressions (line 28078) | function findConstantAndWatchExpressions(ast, $filter) {
function getInputs (line 28182) | function getInputs(body) {
function isAssignable (line 28190) | function isAssignable(ast) {
function assignableAST (line 28194) | function assignableAST(ast) {
function isLiteral (line 28200) | function isLiteral(ast) {
function isConstant (line 28208) | function isConstant(ast) {
function ASTCompiler (line 28212) | function ASTCompiler(astBuilder, $filter) {
function ASTInterpreter (line 28704) | function ASTInterpreter(astBuilder, $filter) {
function isPossiblyDangerousMemberName (line 29097) | function isPossiblyDangerousMemberName(name) {
function getValueOf (line 29103) | function getValueOf(value) {
function $ParseProvider (line 29158) | function $ParseProvider() {
function $QProvider (line 29590) | function $QProvider() {
function $$QProvider (line 29599) | function $$QProvider() {
function qFactory (line 29615) | function qFactory(nextTick, exceptionHandler) {
function $$RAFProvider (line 29969) | function $$RAFProvider() { //rAF
function $RootScopeProvider (line 30066) | function $RootScopeProvider() {
function $$SanitizeUriProvider (line 31367) | function $$SanitizeUriProvider() {
function adjustMatcher (line 31458) | function adjustMatcher(matcher) {
function adjustMatchers (line 31486) | function adjustMatchers(matchers) {
function $SceDelegateProvider (line 31564) | function $SceDelegateProvider() {
function $SceProvider (line 32094) | function $SceProvider() {
function $SnifferProvider (line 32506) | function $SnifferProvider() {
function $TemplateRequestProvider (line 32600) | function $TemplateRequestProvider() {
function $$TestabilityProvider (line 32653) | function $$TestabilityProvider() {
function $TimeoutProvider (line 32768) | function $TimeoutProvider() {
function urlResolve (line 32919) | function urlResolve(url) {
function urlIsSameOrigin (line 32953) | function urlIsSameOrigin(requestUrl) {
function $WindowProvider (line 33000) | function $WindowProvider() {
function $$CookieReader (line 33013) | function $$CookieReader($document) {
function $$CookieReaderProvider (line 33055) | function $$CookieReaderProvider() {
function $FilterProvider (line 33159) | function $FilterProvider($provide) {
function filterFilter (line 33349) | function filterFilter() {
function createPredicateFn (line 33386) | function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
function deepCompare (line 33423) | function deepCompare(actual, expected, comparator, matchAgainstAnyProp, ...
function getTypeForFilter (line 33473) | function getTypeForFilter(val) {
function currencyFilter (line 33530) | function currencyFilter($locale) {
function numberFilter (line 33604) | function numberFilter($locale) {
function formatNumber (line 33617) | function formatNumber(number, pattern, groupSep, decimalSep, fractionSiz...
function padNumber (line 33705) | function padNumber(num, digits, trim) {
function dateGetter (line 33720) | function dateGetter(name, size, offset, trim) {
function dateStrGetter (line 33732) | function dateStrGetter(name, shortForm) {
function timeZoneGetter (line 33741) | function timeZoneGetter(date, formats, offset) {
function getFirstThursdayOfYear (line 33751) | function getFirstThursdayOfYear(year) {
function getThursdayThisWeek (line 33759) | function getThursdayThisWeek(datetime) {
function weekGetter (line 33765) | function weekGetter(size) {
function ampmGetter (line 33777) | function ampmGetter(date, formats) {
function eraGetter (line 33781) | function eraGetter(date, formats) {
function longEraGetter (line 33785) | function longEraGetter(date, formats) {
function dateFilter (line 33919) | function dateFilter($locale) {
function jsonFilter (line 34026) | function jsonFilter() {
function limitToFilter (line 34155) | function limitToFilter() {
function orderByFilter (line 34356) | function orderByFilter($parse) {
function ngDirective (line 34474) | function ngDirective(directive) {
function defaultLinkFn (line 34876) | function defaultLinkFn(scope, element, attr) {
function nullFormRenameControl (line 34978) | function nullFormRenameControl(control, name) {
function FormController (line 35026) | function FormController(element, attrs, $scope, $animate, $interpolate) {
function getSetter (line 35504) | function getSetter(expression) {
function stringBasedInputType (line 36594) | function stringBasedInputType(ctrl) {
function textInputType (line 36600) | function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function baseInputType (line 36605) | function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function weekParser (line 36695) | function weekParser(isoWeek, existingDate) {
function createDateParser (line 36727) | function createDateParser(regexp, mapping) {
function createDateInputType (line 36777) | function createDateInputType(type, regexp, parseDate, format) {
function badInputChecker (line 36849) | function badInputChecker(scope, element, attr, ctrl) {
function numberInputType (line 36864) | function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function urlInputType (line 36918) | function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function emailInputType (line 36931) | function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
function radioInputType (line 36944) | function radioInputType(scope, element, attr, ctrl) {
function parseConstantExpr (line 36966) | function parseConstantExpr($parse, context, name, expression, fallback) {
function checkboxInputType (line 36979) | function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browse...
function classDirective (line 37562) | function classDirective(name, selector) {
function processParseErrors (line 40113) | function processParseErrors() {
function processSyncValidators (line 40133) | function processSyncValidators() {
function processAsyncValidators (line 40149) | function processAsyncValidators() {
function setValidity (line 40175) | function setValidity(name, isValid) {
function validationDone (line 40181) | function validationDone(allValid) {
function writeToModelIfNeeded (line 40260) | function writeToModelIfNeeded() {
function addSetValidityMethod (line 40815) | function addSetValidityMethod(context) {
function isObjectEmpty (line 40909) | function isObjectEmpty(obj) {
function parseOptionsExpression (line 41201) | function parseOptionsExpression(optionsExp, selectElement, scope) {
function ngOptionsPostLink (line 41364) | function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
function updateElementText (line 41948) | function updateElementText(newText) {
function chromeHack (line 43208) | function chromeHack(optionElement) {
function selectPreLink (line 43566) | function selectPreLink(scope, element, attr, ctrls) {
function getDecimals (line 43787) | function getDecimals(n) {
function getVF (line 43793) | function getVF(n, opt_precision) {
function utils_hooks__hooks (line 43939) | function utils_hooks__hooks () {
function setHookCallback (line 43945) | function setHookCallback (callback) {
function isArray (line 43949) | function isArray(input) {
function isDate (line 43953) | function isDate(input) {
function map (line 43957) | function map(arr, fn) {
function hasOwnProp (line 43965) | function hasOwnProp(a, b) {
function extend (line 43969) | function extend(a, b) {
function create_utc__createUTC (line 43987) | function create_utc__createUTC (input, format, locale, strict) {
function defaultParsingFlags (line 43991) | function defaultParsingFlags() {
function getParsingFlags (line 44007) | function getParsingFlags(m) {
function valid__isValid (line 44014) | function valid__isValid(m) {
function valid__createInvalid (line 44036) | function valid__createInvalid (flags) {
function isUndefined (line 44048) | function isUndefined(input) {
function copyConfig (line 44056) | function copyConfig(to, from) {
function Moment (line 44106) | function Moment(config) {
function isMoment (line 44118) | function isMoment (obj) {
function absFloor (line 44122) | function absFloor (number) {
function toInt (line 44130) | function toInt(argumentForCoercion) {
function compareArrays (line 44142) | function compareArrays(array1, array2, dontConvert) {
function Locale (line 44156) | function Locale() {
function normalizeLocale (line 44163) | function normalizeLocale(key) {
function chooseLocale (line 44170) | function chooseLocale(names) {
function loadLocale (line 44194) | function loadLocale(name) {
function locale_locales__getSetGlobalLocale (line 44213) | function locale_locales__getSetGlobalLocale (key, values) {
function defineLocale (line 44232) | function defineLocale (name, values) {
function locale_locales__getLocale (line 44250) | function locale_locales__getLocale (key) {
function addUnitAlias (line 44275) | function addUnitAlias (unit, shorthand) {
function normalizeUnits (line 44280) | function normalizeUnits(units) {
function normalizeObjectUnits (line 44284) | function normalizeObjectUnits(inputObject) {
function isFunction (line 44301) | function isFunction(input) {
function makeGetSet (line 44305) | function makeGetSet (unit, keepTime) {
function get_set__get (line 44317) | function get_set__get (mom, unit) {
function get_set__set (line 44322) | function get_set__set (mom, unit, value) {
function getSet (line 44330) | function getSet (units, value) {
function zeroFill (line 44345) | function zeroFill(number, targetLength, forceSign) {
function addFormatToken (line 44365) | function addFormatToken (token, padded, ordinal, callback) {
function removeFormattingTokens (line 44387) | function removeFormattingTokens(input) {
function makeFormatFunction (line 44394) | function makeFormatFunction(format) {
function formatMoment (line 44415) | function formatMoment(m, format) {
function expandFormat (line 44426) | function expandFormat(format, locale) {
function addRegexToken (line 44470) | function addRegexToken (token, regex, strictRegex) {
function getParseRegexForToken (line 44476) | function getParseRegexForToken (token, config) {
function unescapeFormat (line 44485) | function unescapeFormat(s) {
function regexEscape (line 44491) | function regexEscape(s) {
function addParseToken (line 44497) | function addParseToken (token, callback) {
function addWeekParseToken (line 44512) | function addWeekParseToken (token, callback) {
function addTimeToArrayFromToken (line 44519) | function addTimeToArrayFromToken(token, input, config) {
function daysInMonth (line 44535) | function daysInMonth(year, month) {
function localeMonths (line 44586) | function localeMonths (m, format) {
function localeMonthsShort (line 44592) | function localeMonthsShort (m, format) {
function localeMonthsParse (line 44597) | function localeMonthsParse (monthName, format, strict) {
function setMonth (line 44630) | function setMonth (mom, value) {
function getSetMonth (line 44652) | function getSetMonth (value) {
function getDaysInMonth (line 44662) | function getDaysInMonth () {
function monthsShortRegex (line 44667) | function monthsShortRegex (isStrict) {
function monthsRegex (line 44684) | function monthsRegex (isStrict) {
function computeMonthsParse (line 44700) | function computeMonthsParse () {
function checkOverflow (line 44732) | function checkOverflow (m) {
function warn (line 44762) | function warn(msg) {
function deprecate (line 44769) | function deprecate(msg, fn) {
function deprecateSimple (line 44783) | function deprecateSimple(name, msg) {
function configFromISO (line 44830) | function configFromISO(config) {
function configFromString (line 44883) | function configFromString(config) {
function createDate (line 44908) | function createDate (y, m, d, h, M, s, ms) {
function createUTCDate (line 44920) | function createUTCDate (y) {
function daysInYear (line 44970) | function daysInYear(year) {
function isLeapYear (line 44974) | function isLeapYear(year) {
function getIsLeapYear (line 44988) | function getIsLeapYear () {
function firstWeekOffset (line 44993) | function firstWeekOffset(year, dow, doy) {
function dayOfYearFromWeeks (line 45003) | function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
function weekOfYear (line 45026) | function weekOfYear(mom, dow, doy) {
function weeksInYear (line 45048) | function weeksInYear(year, dow, doy) {
function defaults (line 45055) | function defaults(a, b, c) {
function currentDateArray (line 45065) | function currentDateArray(config) {
function configFromArray (line 45078) | function configFromArray (config) {
function dayOfYearFromWeekInfo (line 45140) | function dayOfYearFromWeekInfo(config) {
function configFromStringAndFormat (line 45197) | function configFromStringAndFormat(config) {
function meridiemFixWrap (line 45263) | function meridiemFixWrap (locale, hour, meridiem) {
function configFromStringAndArray (line 45289) | function configFromStringAndArray(config) {
function configFromObject (line 45333) | function configFromObject(config) {
function createFromConfig (line 45346) | function createFromConfig (config) {
function prepareConfig (line 45357) | function prepareConfig (config) {
function configFromInput (line 45390) | function configFromInput(config) {
function createLocalOrUTC (line 45413) | function createLocalOrUTC (input, format, locale, strict, isUTC) {
function local__createLocal (line 45432) | function local__createLocal (input, format, locale, strict) {
function pickBy (line 45465) | function pickBy(fn, moments) {
function min (line 45483) | function min () {
function max (line 45489) | function max () {
function Duration (line 45499) | function Duration (duration) {
function isDuration (line 45534) | function isDuration (obj) {
function offset (line 45540) | function offset (token, separator) {
function offsetFromString (line 45571) | function offsetFromString(matcher, string) {
function cloneWithOffset (line 45581) | function cloneWithOffset(input, model) {
function getDateOffset (line 45595) | function getDateOffset (m) {
function getSetOffset (line 45619) | function getSetOffset (input, keepLocalTime) {
function getSetZone (line 45654) | function getSetZone (input, keepLocalTime) {
function setOffsetToUTC (line 45668) | function setOffsetToUTC (keepLocalTime) {
function setOffsetToLocal (line 45672) | function setOffsetToLocal (keepLocalTime) {
function setOffsetToParsedOffset (line 45684) | function setOffsetToParsedOffset () {
function hasAlignedHourOffset (line 45693) | function hasAlignedHourOffset (input) {
function isDaylightSavingTime (line 45702) | function isDaylightSavingTime () {
function isDaylightSavingTimeShifted (line 45709) | function isDaylightSavingTimeShifted () {
function isLocal (line 45730) | function isLocal () {
function isUtcOffset (line 45734) | function isUtcOffset () {
function isUtc (line 45738) | function isUtc () {
function create__createDuration (line 45749) | function create__createDuration (input, key) {
function parseIso (line 45812) | function parseIso (inp, sign) {
function positiveMomentsDifference (line 45821) | function positiveMomentsDifference(base, other) {
function momentsDifference (line 45835) | function momentsDifference(base, other) {
function createAdder (line 45854) | function createAdder(direction, name) {
function add_subtract__addSubtract (line 45870) | function add_subtract__addSubtract (mom, duration, isAdding, updateOffse...
function moment_calendar__calendar (line 45899) | function moment_calendar__calendar (time, formats) {
function clone (line 45917) | function clone () {
function isAfter (line 45921) | function isAfter (input, units) {
function isBefore (line 45934) | function isBefore (input, units) {
function isBetween (line 45947) | function isBetween (from, to, units) {
function isSame (line 45951) | function isSame (input, units) {
function isSameOrAfter (line 45966) | function isSameOrAfter (input, units) {
function isSameOrBefore (line 45970) | function isSameOrBefore (input, units) {
function diff (line 45974) | function diff (input, units, asFloat) {
function monthDiff (line 46012) | function monthDiff (a, b) {
function toString (line 46034) | function toString () {
function moment_format__toISOString (line 46038) | function moment_format__toISOString () {
function format (line 46052) | function format (inputString) {
function from (line 46057) | function from (time, withoutSuffix) {
function fromNow (line 46067) | function fromNow (withoutSuffix) {
function to (line 46071) | function to (time, withoutSuffix) {
function toNow (line 46081) | function toNow (withoutSuffix) {
function locale (line 46088) | function locale (key) {
function localeData (line 46113) | function localeData () {
function startOf (line 46117) | function startOf (units) {
function endOf (line 46160) | function endOf (units) {
function to_type__valueOf (line 46168) | function to_type__valueOf () {
function unix (line 46172) | function unix () {
function toDate (line 46176) | function toDate () {
function toArray (line 46180) | function toArray () {
function toObject (line 46185) | function toObject () {
function toJSON (line 46198) | function toJSON () {
function moment_valid__isValid (line 46203) | function moment_valid__isValid () {
function parsingFlags (line 46207) | function parsingFlags () {
function invalidAt (line 46211) | function invalidAt () {
function creationData (line 46215) | function creationData() {
function addWeekYearFormatToken (line 46235) | function addWeekYearFormatToken (token, getter) {
function getSetWeekYear (line 46270) | function getSetWeekYear (input) {
function getSetISOWeekYear (line 46279) | function getSetISOWeekYear (input) {
function getISOWeeksInYear (line 46284) | function getISOWeeksInYear () {
function getWeeksInYear (line 46288) | function getWeeksInYear () {
function getSetWeekYearHelper (line 46293) | function getSetWeekYearHelper(input, week, weekday, dow, doy) {
function setWeekAll (line 46306) | function setWeekAll(weekYear, week, weekday, dow, doy) {
function getSetQuarter (line 46334) | function getSetQuarter (input) {
function localeWeek (line 46363) | function localeWeek (mom) {
function localeFirstDayOfWeek (line 46372) | function localeFirstDayOfWeek () {
function localeFirstDayOfYear (line 46376) | function localeFirstDayOfYear () {
function getSetWeek (line 46382) | function getSetWeek (input) {
function getSetISOWeek (line 46387) | function getSetISOWeek (input) {
function parseWeekday (line 46467) | function parseWeekday(input, locale) {
function localeWeekdays (line 46487) | function localeWeekdays (m, format) {
function localeWeekdaysShort (line 46493) | function localeWeekdaysShort (m) {
function localeWeekdaysMin (line 46498) | function localeWeekdaysMin (m) {
function localeWeekdaysParse (line 46502) | function localeWeekdaysParse (weekdayName, format, strict) {
function getSetDayOfWeek (line 46540) | function getSetDayOfWeek (input) {
function getSetLocaleDayOfWeek (line 46553) | function getSetLocaleDayOfWeek (input) {
function getSetISODayOfWeek (line 46561) | function getSetISODayOfWeek (input) {
function getSetDayOfYear (line 46591) | function getSetDayOfYear (input) {
function hFormat (line 46598) | function hFormat() {
function meridiem (line 46623) | function meridiem (token, lowercase) {
function matchMeridiem (line 46638) | function matchMeridiem (isStrict, locale) {
function localeIsPM (line 46692) | function localeIsPM (input) {
function localeMeridiem (line 46699) | function localeMeridiem (hours, minutes, isLower) {
function parseMs (line 46798) | function parseMs(input, array) {
function getZoneAbbr (line 46816) | function getZoneAbbr () {
function getZoneName (line 46820) | function getZoneName () {
function moment__createUnix (line 46929) | function moment__createUnix (input) {
function moment__createInZone (line 46933) | function moment__createInZone () {
function locale_calendar__calendar (line 46946) | function locale_calendar__calendar (key, mom, now) {
function longDateFormat (line 46960) | function longDateFormat (key) {
function invalidDate (line 46977) | function invalidDate () {
function ordinal (line 46984) | function ordinal (number) {
function preParsePostFormat (line 46988) | function preParsePostFormat (string) {
function relative__relativeTime (line 47008) | function relative__relativeTime (number, withoutSuffix, string, isFuture) {
function pastFuture (line 47015) | function pastFuture (diff, output) {
function locale_set__set (line 47020) | function locale_set__set (config) {
function lists__get (line 47084) | function lists__get (format, index, field, setter) {
function list (line 47090) | function list (format, index, field, count, setter) {
function lists__listMonths (line 47110) | function lists__listMonths (format, index) {
function lists__listMonthsShort (line 47114) | function lists__listMonthsShort (format, index) {
function lists__listWeekdays (line 47118) | function lists__listWeekdays (format, index) {
function lists__listWeekdaysShort (line 47122) | function lists__listWeekdaysShort (format, index) {
function lists__listWeekdaysMin (line 47126) | function lists__listWeekdaysMin (format, index) {
function duration_abs__abs (line 47148) | function duration_abs__abs () {
function duration_add_subtract__addSubtract (line 47165) | function duration_add_subtract__addSubtract (duration, input, value, dir...
function duration_add_subtract__add (line 47176) | function duration_add_subtract__add (input, value) {
function duration_add_subtract__subtract (line 47181) | function duration_add_subtract__subtract (input, value) {
function absCeil (line 47185) | function absCeil (number) {
function bubble (line 47193) | function bubble () {
function daysToMonths (line 47240) | function daysToMonths (days) {
function monthsToDays (line 47246) | function monthsToDays (months) {
function as (line 47251) | function as (units) {
function duration_as__valueOf (line 47279) | function duration_as__valueOf () {
function makeAs (line 47288) | function makeAs (alias) {
function duration_get__get (line 47303) | function duration_get__get (units) {
function makeGetter (line 47308) | function makeGetter(name) {
function weeks (line 47322) | function weeks () {
function substituteTimeAgo (line 47336) | function substituteTimeAgo(string, number, withoutSuffix, isFuture, loca...
function duration_humanize__relativeTime (line 47340) | function duration_humanize__relativeTime (posNegDuration, withoutSuffix,...
function duration_humanize__getSetRelativeTimeThreshold (line 47367) | function duration_humanize__getSetRelativeTimeThreshold (threshold, limi...
function humanize (line 47378) | function humanize (withSuffix) {
function iso_string__toISOString (line 47391) | function iso_string__toISOString() {
function webpackContext (line 47747) | function webpackContext(req) {
function webpackContextResolve (line 47750) | function webpackContextResolve(req) {
function plural (line 48334) | function plural(word, num) {
function relativeTimeWithPlural (line 48338) | function relativeTimeWithPlural(number, withoutSuffix, key) {
function relativeTimeWithMutation (line 48795) | function relativeTimeWithMutation(number, withoutSuffix, key) {
function specialMutationForYears (line 48803) | function specialMutationForYears(number) {
function lastNumber (line 48815) | function lastNumber(number) {
function mutation (line 48821) | function mutation(text, number) {
function softMutation (line 48827) | function softMutation(text) {
function translate (line 48907) | function translate(number, withoutSuffix, key) {
function plural (line 49136) | function plural(n) {
function translate (line 49139) | function translate(number, withoutSuffix, key, isFuture) {
function processRelativeTime (line 49525) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function processRelativeTime (line 49606) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function isFunction (line 49786) | function isFunction(input) {
function processRelativeTime (line 50399) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function translate (line 50664) | function translate(number, withoutSuffix, key, isFuture) {
function verbalNumber (line 50698) | function verbalNumber(number, isFuture) {
function translate (line 51475) | function translate(number, withoutSuffix, key) {
function translate (line 51623) | function translate(number, withoutSuffix, key, isFuture) {
function week (line 51652) | function week(isFuture) {
function plural (line 51921) | function plural(n) {
function translate (line 51929) | function translate(number, withoutSuffix, key, isFuture) {
function processRelativeTime (line 52600) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function processFutureTime (line 52610) | function processFutureTime(string) {
function processPastTime (line 52617) | function processPastTime(string) {
function eifelerRegelAppliesToNumber (line 52631) | function eifelerRegelAppliesToNumber(number) {
function translateSeconds (line 52823) | function translateSeconds(number, withoutSuffix, key, isFuture) {
function translateSingular (line 52830) | function translateSingular(number, withoutSuffix, key, isFuture) {
function special (line 52833) | function special(number) {
function forms (line 52836) | function forms(key) {
function translate (line 52839) | function translate(number, withoutSuffix, key, isFuture) {
function format (line 52946) | function format(forms, number, withoutSuffix) {
function relativeTimeWithPlural (line 52956) | function relativeTimeWithPlural(number, withoutSuffix, key) {
function relativeTimeWithSingular (line 52959) | function relativeTimeWithSingular(number, withoutSuffix, key) {
function relativeSeconds (line 52962) | function relativeSeconds(number, withoutSuffix) {
function relativeTimeMr (line 53338) | function relativeTimeMr(number, withoutSuffix, string, isFuture)
function plural (line 54074) | function plural(n) {
function translate (line 54077) | function translate(number, withoutSuffix, key) {
function relativeTimeWithPlural (line 54314) | function relativeTimeWithPlural(number, withoutSuffix, key) {
function plural (line 54392) | function plural(word, num) {
function relativeTimeWithPlural (line 54396) | function relativeTimeWithPlural(number, withoutSuffix, key) {
function plural (line 54699) | function plural(n) {
function translate (line 54702) | function translate(number, withoutSuffix, key, isFuture) {
function processRelativeTime (line 54850) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function translateFuture (line 55806) | function translateFuture(output) {
function translatePast (line 55818) | function translatePast(output) {
function translate (line 55830) | function translate(number, withoutSuffix, string, isFuture) {
function numberAsNoun (line 55846) | function numberAsNoun(number) {
function processRelativeTime (line 56076) | function processRelativeTime(number, withoutSuffix, key, isFuture) {
function plural (line 56237) | function plural(word, num) {
function relativeTimeWithPlural (line 56241) | function relativeTimeWithPlural(number, withoutSuffix, key) {
function weekdaysCaseReplace (line 56259) | function weekdaysCaseReplace(m, format) {
function processHoursFunction (line 56272) | function processHoursFunction(str) {
function generateCalendar (line 57046) | function generateCalendar()
function checkLocale (line 57100) | function checkLocale(locale)
function checkDialogHeight (line 57192) | function checkDialogHeight(dialogId)
function open (line 57288) | function open(dropdownScope)
function close (line 57303) | function close(dropdownScope)
function closeDropdown (line 57312) | function closeDropdown()
function linkList (line 57352) | function linkList()
function unlinkList (line 57359) | function unlinkList()
function setDropdownMenuCss (line 57372) | function setDropdownMenuCss()
function openDropdownMenu (line 57435) | function openDropdownMenu()
function closeDropdownMenu (line 57483) | function closeDropdownMenu()
function setFileName (line 57662) | function setFileName(val)
function getElementHeight (line 57699) | function getElementHeight(elem)
function moveNotificationUp (line 57705) | function moveNotificationUp()
function deleteNotification (line 57725) | function deleteNotification(notification)
function notify (line 57744) | function notify(text, icon, sticky, color)
function success (line 57799) | function success(text, sticky)
function error (line 57804) | function error(text, sticky)
function warning (line 57809) | function warning(text, sticky)
function info (line 57814) | function info(text, sticky)
function buildDialogHeader (line 57825) | function buildDialogHeader(title)
function buildDialogContent (line 57837) | function buildDialogContent(text)
function buildDialogActions (line 57849) | function buildDialogActions(buttons, callback)
function confirm (line 57904) | function confirm(title, text, buttons, callback)
function alert (line 57937) | function alert(title, text, button, callback)
function closeDialog (line 57971) | function closeDialog()
function init (line 58015) | function init()
function showCircular (line 58047) | function showCircular(color, container)
function hideCircular (line 58055) | function hideCircular()
function showCircularProgress (line 58063) | function showCircularProgress(color, container)
function hideCircularProgress (line 58084) | function hideCircularProgress()
function showLinear (line 58096) | function showLinear(color, container)
function hideLinear (line 58104) | function hideLinear()
function showLinearProgress (line 58112) | function showLinearProgress(color, container)
function hideLinearProgress (line 58135) | function hideLinearProgress()
function update (line 58238) | function update()
function setScrollPercent (line 58243) | function setScrollPercent(id, newVal)
function getScrollPercent (line 58253) | function getScrollPercent(id)
function initScrollbar (line 58378) | function initScrollbar()
function updateScroll (line 58399) | function updateScroll(handlePosition, scrollPosition)
function updatePosition (line 58418) | function updatePosition(handlePosition, scrollPosition)
function arrayObjectIndexOf (line 58559) | function arrayObjectIndexOf(arr, obj)
function select (line 58584) | function select(choice)
function unselect (line 58600) | function unselect(element, event)
function toggle (line 58620) | function toggle(choice, event)
function isSelected (line 58638) | function isSelected(choice)
function hasNoResults (line 58643) | function hasNoResults()
function filterNeeded (line 58648) | function filterNeeded()
function isHelperVisible (line 58653) | function isHelperVisible()
function isChoicesVisible (line 58658) | function isChoicesVisible()
function getSelectedElements (line 58667) | function getSelectedElements()
function getSelectedTemplate (line 58672) | function getSelectedTemplate()
function convertValue (line 58677) | function convertValue(newValue, conversion, callback)
function getTabs (line 59066) | function getTabs()
function setActiveTab (line 59071) | function setActiveTab(index)
function setLinksColor (line 59079) | function setLinksColor(newTab)
function setIndicatorPosition (line 59085) | function setIndicatorPosition(oldTab)
function focusUpdate (line 59301) | function focusUpdate()
function blurUpdate (line 59307) | function blurUpdate()
function modelUpdate (line 59313) | function modelUpdate()
function valueUpdate (line 59318) | function valueUpdate()
function updateTextareaHeight (line 59324) | function updateTextareaHeight()
function addImage (line 59405) | function addImage()
function _classCallCheck (line 59840) | function _classCallCheck(instance, Constructor) { if (!(instance instanc...
FILE: Part3/app/core/nav/nav.js
class NavCtrl (line 1) | class NavCtrl {
method constructor (line 2) | constructor() {
Condensed preview — 38 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,875K chars).
[
{
"path": ".gitignore",
"chars": 177,
"preview": ".idea\nPart1/node_modules\nPart2/node_modules\nPart3/node_modules\nPart2/app/bower_components\nPart3/app/bower_components\nPar"
},
{
"path": "Part1/.jshintrc",
"chars": 97,
"preview": "{\n \"esnext\": true,\n \"node\": true,\n \"globals\": {\n \"angular\": true,\n \"console\": true\n }\n}"
},
{
"path": "Part1/README.md",
"chars": 9747,
"preview": "##### Part 1\n\n<div class=\"update\">Updated Jan 16th, 2016.</div>\n\n# Getting Started\n\nThere are a lot of module loaders ou"
},
{
"path": "Part1/app/bundle.js",
"chars": 1132140,
"preview": "/******/ (function(modules) { // webpackBootstrap\n/******/ \tvar parentHotUpdateCallback = this[\"webpackHotUpdate\"];\n/***"
},
{
"path": "Part1/app/core/bootstrap.js",
"chars": 230,
"preview": "/*jshint browser:true */\n'use strict';\n\nrequire('./vendor.js')();\nvar appModule = require('../index');\n\nangular.element("
},
{
"path": "Part1/app/core/vendor.js",
"chars": 110,
"preview": "module.exports = function () {\n /* Styles */\n require('../index.scss');\n\n /* JS */\n require('angular');\n};"
},
{
"path": "Part1/app/index.html",
"chars": 213,
"preview": "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <title>Webpack Angular Part 1</title>\n</head>\n<body>\n"
},
{
"path": "Part1/app/index.js",
"chars": 251,
"preview": "'use strict';\n\nmodule.exports = angular.module('app', []);\n\nfunction printMessage (status='working') {\t\t// default param"
},
{
"path": "Part1/app/index.scss",
"chars": 33,
"preview": "body {\n background-color: red;\n}"
},
{
"path": "Part1/package.json",
"chars": 819,
"preview": "{\n \"name\": \"WebpackAngular\",\n \"version\": \"0.4.0\",\n \"description\": \"Webpack Angular Demo: Setup\",\n \"main\": \"index.js\""
},
{
"path": "Part1/webpack.config.js",
"chars": 649,
"preview": "'use strict';\nvar webpack = require('webpack'),\n path = require('path');\n\n// PATHS\nvar PATHS = {\n app: __dirname + '/a"
},
{
"path": "Part2/.jshintrc",
"chars": 97,
"preview": "{\n \"esnext\": true,\n \"node\": true,\n \"globals\": {\n \"angular\": true,\n \"console\": true\n }\n}"
},
{
"path": "Part2/README.md",
"chars": 8106,
"preview": "#####Part 2\n#Complex Webpack Dependencies\n\nIf you're unfamiliar with Webpack, you might want to checkout [Part 1](http:/"
},
{
"path": "Part2/app/bundle.js",
"chars": 998146,
"preview": "/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/*"
},
{
"path": "Part2/app/core/bootstrap.js",
"chars": 230,
"preview": "/*jshint browser:true */\n'use strict';\n\nrequire('./vendor.js')();\nvar appModule = require('../index');\n\nangular.element("
},
{
"path": "Part2/app/core/vendor.js",
"chars": 319,
"preview": "module.exports = function () {\n /* Styles */\n require('../index.scss');\n require('../../node_modules/mdi/css/material"
},
{
"path": "Part2/app/index.html",
"chars": 289,
"preview": "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <title>Webpack Angular Part 2</title>\n</head>\n<body>\n"
},
{
"path": "Part2/app/index.js",
"chars": 68,
"preview": "'use strict';\n\nmodule.exports = angular.module('app', [\n 'lumx'\n]);"
},
{
"path": "Part2/app/index.scss",
"chars": 58,
"preview": "@import '../node_modules/node-lumx/dist/scss/_lumx.scss';\n"
},
{
"path": "Part2/package.json",
"chars": 1078,
"preview": "{\n \"name\": \"WebpackAngular\",\n \"version\": \"0.4.0\",\n \"description\": \"Webpack Angular Demo: Setup\",\n \"main\": \"index.js\""
},
{
"path": "Part2/webpack.config.js",
"chars": 799,
"preview": "'use strict';\n\nvar webpack = require('webpack'),\n path = require('path'),\n APP = __dirname + '/app';\n\nmodule.exports ="
},
{
"path": "Part3/.jshintrc",
"chars": 97,
"preview": "{\n \"esnext\": true,\n \"node\": true,\n \"globals\": {\n \"angular\": true,\n \"console\": true\n }\n}"
},
{
"path": "Part3/README.md",
"chars": 8494,
"preview": "#####Part 3\n# 6 Ways to use Webpack Require with Angular\n\nFor some reason, Webpack & Angular reminds me of late 90s Acne"
},
{
"path": "Part3/app/bundle.js",
"chars": 2395508,
"preview": "/******/ (function(modules) { // webpackBootstrap\n/******/ \tvar parentHotUpdateCallback = this[\"webpackHotUpdate\"];\n/***"
},
{
"path": "Part3/app/core/bootstrap.js",
"chars": 324,
"preview": "/*jshint browser:true */\n'use strict';\n\nrequire('./vendor.js')();\nvar appModule = require('../index');\n\nif (MODE.product"
},
{
"path": "Part3/app/core/config/production.js",
"chars": 184,
"preview": "export default (appModule) => {\n appModule.config(($compileProvider, $httpProvider) => {\n $compileProvider.debugInfo"
},
{
"path": "Part3/app/core/layout.js",
"chars": 97,
"preview": "export default angular.module('app.layout', [])\n .directive('lumxNavbar', require('./nav/nav'));"
},
{
"path": "Part3/app/core/nav/nav.html",
"chars": 1128,
"preview": "<header class=\"header bgc-light-blue-600\" ng-cloak>\n <h1 class=\"main-logo\">\n <a href=\"/\" class=\"main-logo__link\" lx-"
},
{
"path": "Part3/app/core/nav/nav.js",
"chars": 231,
"preview": "class NavCtrl {\n constructor() {\n this.app = require('index.json');\n }\n}\n\nexport default () => {\n require('./nav.s"
},
{
"path": "Part3/app/core/nav/nav.scss",
"chars": 1530,
"preview": ".header {\n position: fixed;\n top: 0;\n right: 0;\n left: 0;\n z-index: 999;\n height: 60px;\n padding: 12px;\n backgro"
},
{
"path": "Part3/app/core/vendor.js",
"chars": 382,
"preview": "module.exports = function () {\n /* Styles */\n require('../index.scss');\n require('../../node_modules/mdi/css/material"
},
{
"path": "Part3/app/index.html",
"chars": 317,
"preview": "<!doctype html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <title>Webpack Angular Part 2</title>\n</head>\n<body>\n"
},
{
"path": "Part3/app/index.js",
"chars": 117,
"preview": "'use strict';\n\nmodule.exports = angular.module('app', [\n 'lumx',\n /* modules */\n require('./core/layout').name\n]);"
},
{
"path": "Part3/app/index.json",
"chars": 261,
"preview": "{\n \"title\": \"Module Loaders\",\n \"version\": \"0.3.0\",\n \"links\": [{\n \"text\": \"Webpack\",\n \"link\": \"http://webpack.gi"
},
{
"path": "Part3/app/index.scss",
"chars": 0,
"preview": ""
},
{
"path": "Part3/package.json",
"chars": 1070,
"preview": "{\n \"name\": \"WebpackAngular\",\n \"version\": \"0.2.0\",\n \"description\": \"Webpack require examples\",\n \"main\": \"app/index.js"
},
{
"path": "Part3/webpack.config.js",
"chars": 1076,
"preview": "'use strict';\nvar webpack = require('webpack'),\n path = require('path'),\n APP = __dirname + '/app';\n\nmodule.exports = "
},
{
"path": "README.md",
"chars": 300,
"preview": "# Webpack Angular Demos\n\nDemos for using Webpack + Angular + Lumx.\n\n* [Part 1: Getting Started](http://www.shmck.com/web"
}
]
About this extraction
This page contains the full source code of the ShMcK/WebpackAngularDemos GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 38 files (4.4 MB), approximately 1.1M tokens, and a symbol index with 1215 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.