├── .gitignore
├── LICENSE
├── README.md
├── client
    ├── index.html
    ├── js
    │   ├── app.js
    │   ├── lib
    │   │   ├── angular.1.0.7.js
    │   │   ├── es5-sham.2.1.0.js
    │   │   └── es5-shim.2.1.0.js
    │   └── pageController
    │   │   ├── baseMixin.js
    │   │   ├── baseNoPrototypeFunctionality.js
    │   │   ├── basePrototypeFunctionality.js
    │   │   ├── inheritByInjector.js
    │   │   ├── inheritPrototypically.js
    │   │   ├── mixinByInjector.js
    │   │   └── mixinWithPrototypicalInheritance.js
    └── partial
    │   ├── generic.html
    │   └── home.html
├── index.js
├── package.json
└── server
    └── express.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .settings
2 | .project
3 | *sublime-*
4 | deploy
5 | node_modules
6 | npm-*
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2013 Reason [reason -A- exratione.com]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the 'Software'), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | AngularJS Controller Inheritance
  2 | ================================
  3 | 
  4 | This package contains some experiments with controller inheritance in AngularJS,
  5 | and a trivial Node.js Express server to view the experiments as a web site.
  6 | 
  7 | How to Manage Similar Pages in AngularJS
  8 | ----------------------------------------
  9 | 
 10 | So your application has a set of pages that are quite similar. They share
 11 | functionality of one form or another, which might differ a little between the
 12 | pages but is fairly similar in overall form.
 13 | 
 14 | There are a couple of approaches you might take in this situation to maximize
 15 | code reuse and clarity:
 16 | 
 17 |   * Move functionality into services, where it can be appropriately factored.
 18 |   * Aggressively carve up the pages into directives and aim for directive reuse.
 19 |   * Create an inheritance hierarchy of page controllers and place common functionality in ancestor controllers.
 20 | 
 21 | All of these are valid approaches, each more or less useful than the others in
 22 | some circumstances, and can be mixed and matched to suit.
 23 | 
 24 | Here we're going to look at methods of creating controller hierarchies.
 25 | 
 26 | Controller Inheritance via $injector
 27 | ------------------------------------
 28 | 
 29 | An example:
 30 | 
 31 | ```
 32 | /**
 33 |  * Define a parent controller.
 34 |  *
 35 |  * @param {Object} $scope
 36 |  */
 37 | function ParentController($scope) {
 38 |   // Only create functions if they haven't already been set by the child.
 39 |   this.decorateScope = this.decorateScope || function () {
 40 |     $scope.decorator = 23;
 41 |   }
 42 | 
 43 |   this.initialize = this.initialize || function () {
 44 |     this.decorateScope();
 45 |   }
 46 | }
 47 | ```
 48 | 
 49 | ```
 50 | /**
 51 |  * Create a child controller, using the $injector to pull in parent definitions.
 52 |  *
 53 |  * @param {Object} $injector
 54 |  * @param {Object} $scope
 55 |  */
 56 | function ChildController($injector, $scope) {
 57 |   // Override the parent function while allowing children to further override
 58 |   // it.
 59 |   this.decorateScope = this.decorateScope || function () {
 60 |     $scope.decorator = 24;
 61 |   }
 62 | 
 63 |   $injector.invoke(ParentController, this, {
 64 |     $scope: $scope
 65 |   });
 66 | }
 67 | ```
 68 | 
 69 | Mixins work in the same way as inheritance:
 70 | 
 71 | ```
 72 | /**
 73 |  * Create a child controller inheriting from several parents.
 74 |  *
 75 |  * @param {Object} $injector
 76 |  * @param {Object} $scope
 77 |  */
 78 | function ChildController($injector, $scope) {
 79 |   // Any number of other controllers can be invoked in this way.
 80 |   $injector.invoke(ParentController, this, {
 81 |     $scope: $scope
 82 |   });
 83 |   $injector.invoke(MixinController, this, {
 84 |     $scope: $scope
 85 |   });
 86 | }
 87 | ```
 88 | 
 89 | In summary:
 90 | 
 91 | * All dependencies must be passed explicitly to $injector.invoke(), or else test code will break because injected mocks will be ignored by the parent class. The parent will load the non-mock instances for anything not explicitly set in $injector.invoke().
 92 | * Unlike prototypical inheritance, parents must explicitly permit overriding.
 93 | * A mixin works in exactly the same way as inheritance.
 94 | * You can't define functionality in the controller constructor prototype. That is ignored by $injector.invoke(). You must define functions inside the constructor body, as shown above.
 95 | 
 96 | Controller Prototype Inheritance
 97 | --------------------------------
 98 | 
 99 | To enable standard-issue Javascript prototypical inheritance we should define an
100 | inherits() function somewhere easily accessible:
101 | 
102 | ```
103 | /**
104 |  * A clone of the Node.js util.inherits() function. This will require
105 |  * browser support for the ES5 Object.create() method.
106 |  *
107 |  * @param {Function} ctor
108 |  *   The child constructor.
109 |  * @param {Function} superCtor
110 |  *   The parent constructor.
111 |  */
112 | angular.inherits = function (ctor, superCtor) {
113 |   ctor.super_ = superCtor;
114 |   ctor.prototype = Object.create(superCtor.prototype, {
115 |     constructor: {
116 |       value: ctor,
117 |       enumerable: false
118 |     }
119 |   });
120 | };
121 | ```
122 | 
123 | An example:
124 | 
125 | ```
126 | /**
127 |  * Define a parent controller.
128 |  *
129 |  * @param {Object} $scope
130 |  */
131 | function ParentController($scope) {
132 |   this.$scope = $scope;
133 |   this.initialize();
134 | }
135 | 
136 | /**
137 |  * Decorate the scope.
138 |  */
139 | ParentController.prototype.decorateScope = function () {
140 |   this.$scope.decorator = 23;
141 | }
142 | 
143 | /**
144 |  * Initialize the controller for use.
145 |  */
146 | ParentController.prototype.initialize = function () {
147 |   this.decorateScope();
148 | }
149 | ```
150 | 
151 | ```
152 | /**
153 |  * Use standard prototypical inheritance for the child.
154 |  *
155 |  * @param {Object} $injector
156 |  * @param {Object} $scope
157 |  */
158 | function ChildController($scope) {
159 |   // No need to explicitly pass the injected dependencies, provided they
160 |   // are ordered consistently.
161 |   ChildController.super_.apply(this, arguments);
162 | }
163 | angular.inherits(ChildController, ParentController);
164 | 
165 | /**
166 |  * Override the parent function.
167 |  * @see ParentController#decorateScope
168 |  */
169 | ChildController.prototype.decorateScope = function () {
170 |   this.$scope.decorator = 24;
171 | }
172 | ```
173 | 
174 | Mixins can be created in a number of ways. For example, by calling the mixin
175 | constructor and coping over its prototype functions.
176 | 
177 | ```
178 | function ChildController($scope) {
179 |   // Invoke the parent constructor.
180 |   ChildController.super_.apply(this, arguments);
181 | 
182 |   // Invoke the mixin constructor. You don't get any of the mixin's
183 |   // prototype methods by doing this, and are also less likely to be able to
184 |   // structure arguments to as to be able to use apply(), so back to passing
185 |   // dependencies explicitly.
186 |   MixinController.call(this, $scope);
187 | }
188 | angular.inherits(ChildController, ParentController);
189 | 
190 | // Add the mixin prototype functionality to the ChildController prototype,
191 | // provided it doesn't already exist - i.e. is overridden.
192 | angular.forEach(MixinController.prototype, function (value, name) {
193 |   if (ChildController.prototype[name] === undefined) {
194 |     ChildController.prototype[name] = value;
195 |   }
196 | });
197 | ```
198 | 
199 | * This method cannot be mixed with the $injector method, as $injector.invoke() does not copy over prototype functionality from parent to child.
200 | * With suitable structuring of dependency parameter order there is no need to explicitly pass injected dependencies.
201 | * Mixins are somewhat graceless: call() the constructor function and clone prototype properties.
202 | * This method requires browser support for Object.create(), such as via es5-sham.js in older browsers.
203 | 
204 | Directive Controller Inheritance
205 | --------------------------------
206 | 
207 | All of the notes above apply equally to inheritance of controllers associated
208 | with directives rather than pages.
209 | 


--------------------------------------------------------------------------------
/client/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <title>AngularJS: Examples of Controller Inheritance</title>
 5 |   <script type="text/javascript" src="js/lib/es5-shim.2.1.0.js"></script>
 6 |   <script type="text/javascript" src="js/lib/es5-sham.2.1.0.js"></script>
 7 |   <script type="text/javascript" src="js/lib/angular.1.0.7.js"></script>
 8 |   <script type="text/javascript" src="js/app.js"></script>
 9 |   <script type="text/javascript" src="js/pageController/baseMixin.js"></script>
10 |   <script type="text/javascript" src="js/pageController/baseNoPrototypeFunctionality.js"></script>
11 |   <script type="text/javascript" src="js/pageController/basePrototypeFunctionality.js"></script>
12 |   <script type="text/javascript" src="js/pageController/inheritByInjector.js"></script>
13 |   <script type="text/javascript" src="js/pageController/inheritPrototypically.js"></script>
14 |   <script type="text/javascript" src="js/pageController/mixinByInjector.js"></script>
15 |   <script type="text/javascript" src="js/pageController/mixinWithPrototypicalInheritance.js"></script>
16 | </head>
17 | <body data-ng-app="inheritance" data-ng-view>
18 |   <!--
19 |     The AngularJS application is going to populate the DOM from
20 |     a loaded partial, so there is no HTML in the body.
21 |   -->
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/client/js/app.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | 
 5 | (function () {
 6 |   'use strict';
 7 | 
 8 |   // Create the example application AngularJS module.
 9 |   var inheritance = angular.module('inheritance', []);
10 | 
11 |   // Use the config function to set up routes.
12 |   inheritance.config(function ($routeProvider) {
13 |     $routeProvider
14 |       .when('/home', {
15 |         templateUrl: '/partial/home.html'
16 |       })
17 |       .when('/inheritByInjector', {
18 |         controller: 'inheritByInjectorController',
19 |         templateUrl: '/partial/generic.html'
20 |       })
21 |       .when('/inheritPrototypically', {
22 |         controller: 'inheritPrototypicallyController',
23 |         templateUrl: '/partial/generic.html'
24 |       })
25 |       .when('/mixinByInjector', {
26 |         controller: 'mixinByInjectorController',
27 |         templateUrl: '/partial/generic.html'
28 |       })
29 |       .when('/mixinWithPrototypicalInheritance', {
30 |         controller: 'mixinWithPrototypicalInheritanceController',
31 |         templateUrl: '/partial/generic.html'
32 |       })
33 |       .otherwise({
34 |         redirectTo: '/home'
35 |       });
36 |   });
37 | 
38 |   // Add a prototypical inheritance function. Note that this will need es5-sham
39 |   // in older browsers to provide Object.create().
40 |   inheritance.inherits = function (ctor, superCtor) {
41 |     ctor.super_ = superCtor;
42 |     ctor.prototype = Object.create(superCtor.prototype, {
43 |       constructor: {
44 |         value: ctor,
45 |         enumerable: false
46 |       }
47 |     });
48 |   };
49 | 
50 | })();
51 | 


--------------------------------------------------------------------------------
/client/js/lib/es5-sham.2.1.0.js:
--------------------------------------------------------------------------------
  1 | // Copyright 2009-2012 by contributors, MIT License
  2 | // vim: ts=4 sts=4 sw=4 expandtab
  3 | 
  4 | // Module systems magic dance
  5 | (function (definition) {
  6 |     // RequireJS
  7 |     if (typeof define == "function") {
  8 |         define(definition);
  9 |     // YUI3
 10 |     } else if (typeof YUI == "function") {
 11 |         YUI.add("es5-sham", definition);
 12 |     // CommonJS and <script>
 13 |     } else {
 14 |         definition();
 15 |     }
 16 | })(function () {
 17 | 
 18 | 
 19 | var call = Function.prototype.call;
 20 | var prototypeOfObject = Object.prototype;
 21 | var owns = call.bind(prototypeOfObject.hasOwnProperty);
 22 | 
 23 | // If JS engine supports accessors creating shortcuts.
 24 | var defineGetter;
 25 | var defineSetter;
 26 | var lookupGetter;
 27 | var lookupSetter;
 28 | var supportsAccessors;
 29 | if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
 30 |     defineGetter = call.bind(prototypeOfObject.__defineGetter__);
 31 |     defineSetter = call.bind(prototypeOfObject.__defineSetter__);
 32 |     lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
 33 |     lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
 34 | }
 35 | 
 36 | // ES5 15.2.3.2
 37 | // http://es5.github.com/#x15.2.3.2
 38 | if (!Object.getPrototypeOf) {
 39 |     // https://github.com/kriskowal/es5-shim/issues#issue/2
 40 |     // http://ejohn.org/blog/objectgetprototypeof/
 41 |     // recommended by fschaefer on github
 42 |     Object.getPrototypeOf = function getPrototypeOf(object) {
 43 |         return object.__proto__ || (
 44 |             object.constructor
 45 |                 ? object.constructor.prototype
 46 |                 : prototypeOfObject
 47 |         );
 48 |     };
 49 | }
 50 | 
 51 | //ES5 15.2.3.3
 52 | //http://es5.github.com/#x15.2.3.3
 53 | 
 54 | function doesGetOwnPropertyDescriptorWork(object) {
 55 |     try {
 56 |         object.sentinel = 0;
 57 |         return Object.getOwnPropertyDescriptor(
 58 |                 object,
 59 |                 "sentinel"
 60 |         ).value === 0;
 61 |     } catch (exception) {
 62 |         // returns falsy
 63 |     }
 64 | }
 65 | 
 66 | //check whether getOwnPropertyDescriptor works if it's given. Otherwise,
 67 | //shim partially.
 68 | if (Object.defineProperty) {
 69 |     var getOwnPropertyDescriptorWorksOnObject = 
 70 |         doesGetOwnPropertyDescriptorWork({});
 71 |     var getOwnPropertyDescriptorWorksOnDom = typeof document == "undefined" ||
 72 |     doesGetOwnPropertyDescriptorWork(document.createElement("div"));
 73 |     if (!getOwnPropertyDescriptorWorksOnDom || 
 74 |             !getOwnPropertyDescriptorWorksOnObject
 75 |     ) {
 76 |         var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
 77 |     }
 78 | }
 79 | 
 80 | if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
 81 |     var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object: ";
 82 | 
 83 |     Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
 84 |         if ((typeof object != "object" && typeof object != "function") || object === null) {
 85 |             throw new TypeError(ERR_NON_OBJECT + object);
 86 |         }
 87 | 
 88 |         // make a valiant attempt to use the real getOwnPropertyDescriptor
 89 |         // for I8's DOM elements.
 90 |         if (getOwnPropertyDescriptorFallback) {
 91 |             try {
 92 |                 return getOwnPropertyDescriptorFallback.call(Object, object, property);
 93 |             } catch (exception) {
 94 |                 // try the shim if the real one doesn't work
 95 |             }
 96 |         }
 97 | 
 98 |         // If object does not owns property return undefined immediately.
 99 |         if (!owns(object, property)) {
100 |             return;
101 |         }
102 | 
103 |         // If object has a property then it's for sure both `enumerable` and
104 |         // `configurable`.
105 |         var descriptor =  { enumerable: true, configurable: true };
106 | 
107 |         // If JS engine supports accessor properties then property may be a
108 |         // getter or setter.
109 |         if (supportsAccessors) {
110 |             // Unfortunately `__lookupGetter__` will return a getter even
111 |             // if object has own non getter property along with a same named
112 |             // inherited getter. To avoid misbehavior we temporary remove
113 |             // `__proto__` so that `__lookupGetter__` will return getter only
114 |             // if it's owned by an object.
115 |             var prototype = object.__proto__;
116 |             object.__proto__ = prototypeOfObject;
117 | 
118 |             var getter = lookupGetter(object, property);
119 |             var setter = lookupSetter(object, property);
120 | 
121 |             // Once we have getter and setter we can put values back.
122 |             object.__proto__ = prototype;
123 | 
124 |             if (getter || setter) {
125 |                 if (getter) {
126 |                     descriptor.get = getter;
127 |                 }
128 |                 if (setter) {
129 |                     descriptor.set = setter;
130 |                 }
131 |                 // If it was accessor property we're done and return here
132 |                 // in order to avoid adding `value` to the descriptor.
133 |                 return descriptor;
134 |             }
135 |         }
136 | 
137 |         // If we got this far we know that object has an own property that is
138 |         // not an accessor so we set it as a value and return descriptor.
139 |         descriptor.value = object[property];
140 |         descriptor.writable = true;
141 |         return descriptor;
142 |     };
143 | }
144 | 
145 | // ES5 15.2.3.4
146 | // http://es5.github.com/#x15.2.3.4
147 | if (!Object.getOwnPropertyNames) {
148 |     Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
149 |         return Object.keys(object);
150 |     };
151 | }
152 | 
153 | // ES5 15.2.3.5
154 | // http://es5.github.com/#x15.2.3.5
155 | if (!Object.create) {
156 | 
157 |     // Contributed by Brandon Benvie, October, 2012
158 |     var createEmpty;
159 |     var supportsProto = Object.prototype.__proto__ === null;
160 |     if (supportsProto || typeof document == 'undefined') {
161 |         createEmpty = function () {
162 |             return { "__proto__": null };
163 |         };
164 |     } else {
165 |         // In old IE __proto__ can't be used to manually set `null`, nor does
166 |         // any other method exist to make an object that inherits from nothing,
167 |         // aside from Object.prototype itself. Instead, create a new global
168 |         // object and *steal* its Object.prototype and strip it bare. This is
169 |         // used as the prototype to create nullary objects.
170 |         createEmpty = function () {
171 |             var iframe = document.createElement('iframe');
172 |             var parent = document.body || document.documentElement;
173 |             iframe.style.display = 'none';
174 |             parent.appendChild(iframe);
175 |             iframe.src = 'javascript:';
176 |             var empty = iframe.contentWindow.Object.prototype;
177 |             parent.removeChild(iframe);
178 |             iframe = null;
179 |             delete empty.constructor;
180 |             delete empty.hasOwnProperty;
181 |             delete empty.propertyIsEnumerable;
182 |             delete empty.isPrototypeOf;
183 |             delete empty.toLocaleString;
184 |             delete empty.toString;
185 |             delete empty.valueOf;
186 |             empty.__proto__ = null;
187 | 
188 |             function Empty() {}
189 |             Empty.prototype = empty;
190 |             // short-circuit future calls
191 |             createEmpty = function () {
192 |                 return new Empty();
193 |             };
194 |             return new Empty();
195 |         };
196 |     }
197 | 
198 |     Object.create = function create(prototype, properties) {
199 | 
200 |         var object;
201 |         function Type() {}  // An empty constructor.
202 | 
203 |         if (prototype === null) {
204 |             object = createEmpty();
205 |         } else {
206 |             if (typeof prototype !== "object" && typeof prototype !== "function") {
207 |                 // In the native implementation `parent` can be `null`
208 |                 // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
209 |                 // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
210 |                 // like they are in modern browsers. Using `Object.create` on DOM elements
211 |                 // is...err...probably inappropriate, but the native version allows for it.
212 |                 throw new TypeError("Object prototype may only be an Object or null"); // same msg as Chrome
213 |             }
214 |             Type.prototype = prototype;
215 |             object = new Type();
216 |             // IE has no built-in implementation of `Object.getPrototypeOf`
217 |             // neither `__proto__`, but this manually setting `__proto__` will
218 |             // guarantee that `Object.getPrototypeOf` will work as expected with
219 |             // objects created using `Object.create`
220 |             object.__proto__ = prototype;
221 |         }
222 | 
223 |         if (properties !== void 0) {
224 |             Object.defineProperties(object, properties);
225 |         }
226 | 
227 |         return object;
228 |     };
229 | }
230 | 
231 | // ES5 15.2.3.6
232 | // http://es5.github.com/#x15.2.3.6
233 | 
234 | // Patch for WebKit and IE8 standard mode
235 | // Designed by hax <hax.github.com>
236 | // related issue: https://github.com/kriskowal/es5-shim/issues#issue/5
237 | // IE8 Reference:
238 | //     http://msdn.microsoft.com/en-us/library/dd282900.aspx
239 | //     http://msdn.microsoft.com/en-us/library/dd229916.aspx
240 | // WebKit Bugs:
241 | //     https://bugs.webkit.org/show_bug.cgi?id=36423
242 | 
243 | function doesDefinePropertyWork(object) {
244 |     try {
245 |         Object.defineProperty(object, "sentinel", {});
246 |         return "sentinel" in object;
247 |     } catch (exception) {
248 |         // returns falsy
249 |     }
250 | }
251 | 
252 | // check whether defineProperty works if it's given. Otherwise,
253 | // shim partially.
254 | if (Object.defineProperty) {
255 |     var definePropertyWorksOnObject = doesDefinePropertyWork({});
256 |     var definePropertyWorksOnDom = typeof document == "undefined" ||
257 |         doesDefinePropertyWork(document.createElement("div"));
258 |     if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
259 |         var definePropertyFallback = Object.defineProperty,
260 |             definePropertiesFallback = Object.defineProperties;
261 |     }
262 | }
263 | 
264 | if (!Object.defineProperty || definePropertyFallback) {
265 |     var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
266 |     var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "
267 |     var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +
268 |                                       "on this javascript engine";
269 | 
270 |     Object.defineProperty = function defineProperty(object, property, descriptor) {
271 |         if ((typeof object != "object" && typeof object != "function") || object === null) {
272 |             throw new TypeError(ERR_NON_OBJECT_TARGET + object);
273 |         }
274 |         if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null) {
275 |             throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
276 |         }
277 |         // make a valiant attempt to use the real defineProperty
278 |         // for I8's DOM elements.
279 |         if (definePropertyFallback) {
280 |             try {
281 |                 return definePropertyFallback.call(Object, object, property, descriptor);
282 |             } catch (exception) {
283 |                 // try the shim if the real one doesn't work
284 |             }
285 |         }
286 | 
287 |         // If it's a data property.
288 |         if (owns(descriptor, "value")) {
289 |             // fail silently if "writable", "enumerable", or "configurable"
290 |             // are requested but not supported
291 |             /*
292 |             // alternate approach:
293 |             if ( // can't implement these features; allow false but not true
294 |                 !(owns(descriptor, "writable") ? descriptor.writable : true) ||
295 |                 !(owns(descriptor, "enumerable") ? descriptor.enumerable : true) ||
296 |                 !(owns(descriptor, "configurable") ? descriptor.configurable : true)
297 |             )
298 |                 throw new RangeError(
299 |                     "This implementation of Object.defineProperty does not " +
300 |                     "support configurable, enumerable, or writable."
301 |                 );
302 |             */
303 | 
304 |             if (supportsAccessors && (lookupGetter(object, property) ||
305 |                                       lookupSetter(object, property)))
306 |             {
307 |                 // As accessors are supported only on engines implementing
308 |                 // `__proto__` we can safely override `__proto__` while defining
309 |                 // a property to make sure that we don't hit an inherited
310 |                 // accessor.
311 |                 var prototype = object.__proto__;
312 |                 object.__proto__ = prototypeOfObject;
313 |                 // Deleting a property anyway since getter / setter may be
314 |                 // defined on object itself.
315 |                 delete object[property];
316 |                 object[property] = descriptor.value;
317 |                 // Setting original `__proto__` back now.
318 |                 object.__proto__ = prototype;
319 |             } else {
320 |                 object[property] = descriptor.value;
321 |             }
322 |         } else {
323 |             if (!supportsAccessors) {
324 |                 throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
325 |             }
326 |             // If we got that far then getters and setters can be defined !!
327 |             if (owns(descriptor, "get")) {
328 |                 defineGetter(object, property, descriptor.get);
329 |             }
330 |             if (owns(descriptor, "set")) {
331 |                 defineSetter(object, property, descriptor.set);
332 |             }
333 |         }
334 |         return object;
335 |     };
336 | }
337 | 
338 | // ES5 15.2.3.7
339 | // http://es5.github.com/#x15.2.3.7
340 | if (!Object.defineProperties || definePropertiesFallback) {
341 |     Object.defineProperties = function defineProperties(object, properties) {
342 |         // make a valiant attempt to use the real defineProperties
343 |         if (definePropertiesFallback) {
344 |             try {
345 |                 return definePropertiesFallback.call(Object, object, properties);
346 |             } catch (exception) {
347 |                 // try the shim if the real one doesn't work
348 |             }
349 |         }
350 | 
351 |         for (var property in properties) {
352 |             if (owns(properties, property) && property != "__proto__") {
353 |                 Object.defineProperty(object, property, properties[property]);
354 |             }
355 |         }
356 |         return object;
357 |     };
358 | }
359 | 
360 | // ES5 15.2.3.8
361 | // http://es5.github.com/#x15.2.3.8
362 | if (!Object.seal) {
363 |     Object.seal = function seal(object) {
364 |         // this is misleading and breaks feature-detection, but
365 |         // allows "securable" code to "gracefully" degrade to working
366 |         // but insecure code.
367 |         return object;
368 |     };
369 | }
370 | 
371 | // ES5 15.2.3.9
372 | // http://es5.github.com/#x15.2.3.9
373 | if (!Object.freeze) {
374 |     Object.freeze = function freeze(object) {
375 |         // this is misleading and breaks feature-detection, but
376 |         // allows "securable" code to "gracefully" degrade to working
377 |         // but insecure code.
378 |         return object;
379 |     };
380 | }
381 | 
382 | // detect a Rhino bug and patch it
383 | try {
384 |     Object.freeze(function () {});
385 | } catch (exception) {
386 |     Object.freeze = (function freeze(freezeObject) {
387 |         return function freeze(object) {
388 |             if (typeof object == "function") {
389 |                 return object;
390 |             } else {
391 |                 return freezeObject(object);
392 |             }
393 |         };
394 |     })(Object.freeze);
395 | }
396 | 
397 | // ES5 15.2.3.10
398 | // http://es5.github.com/#x15.2.3.10
399 | if (!Object.preventExtensions) {
400 |     Object.preventExtensions = function preventExtensions(object) {
401 |         // this is misleading and breaks feature-detection, but
402 |         // allows "securable" code to "gracefully" degrade to working
403 |         // but insecure code.
404 |         return object;
405 |     };
406 | }
407 | 
408 | // ES5 15.2.3.11
409 | // http://es5.github.com/#x15.2.3.11
410 | if (!Object.isSealed) {
411 |     Object.isSealed = function isSealed(object) {
412 |         return false;
413 |     };
414 | }
415 | 
416 | // ES5 15.2.3.12
417 | // http://es5.github.com/#x15.2.3.12
418 | if (!Object.isFrozen) {
419 |     Object.isFrozen = function isFrozen(object) {
420 |         return false;
421 |     };
422 | }
423 | 
424 | // ES5 15.2.3.13
425 | // http://es5.github.com/#x15.2.3.13
426 | if (!Object.isExtensible) {
427 |     Object.isExtensible = function isExtensible(object) {
428 |         // 1. If Type(O) is not Object throw a TypeError exception.
429 |         if (Object(object) !== object) {
430 |             throw new TypeError(); // TODO message
431 |         }
432 |         // 2. Return the Boolean value of the [[Extensible]] internal property of O.
433 |         var name = '';
434 |         while (owns(object, name)) {
435 |             name += '?';
436 |         }
437 |         object[name] = true;
438 |         var returnValue = owns(object, name);
439 |         delete object[name];
440 |         return returnValue;
441 |     };
442 | }
443 | 
444 | });
445 | 


--------------------------------------------------------------------------------
/client/js/lib/es5-shim.2.1.0.js:
--------------------------------------------------------------------------------
   1 | // Copyright 2009-2012 by contributors, MIT License
   2 | // vim: ts=4 sts=4 sw=4 expandtab
   3 | 
   4 | // Module systems magic dance
   5 | (function (definition) {
   6 |     // RequireJS
   7 |     if (typeof define == "function") {
   8 |         define(definition);
   9 |     // YUI3
  10 |     } else if (typeof YUI == "function") {
  11 |         YUI.add("es5", definition);
  12 |     // CommonJS and <script>
  13 |     } else {
  14 |         definition();
  15 |     }
  16 | })(function () {
  17 | 
  18 | /**
  19 |  * Brings an environment as close to ECMAScript 5 compliance
  20 |  * as is possible with the facilities of erstwhile engines.
  21 |  *
  22 |  * Annotated ES5: http://es5.github.com/ (specific links below)
  23 |  * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
  24 |  * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/
  25 |  */
  26 | 
  27 | //
  28 | // Function
  29 | // ========
  30 | //
  31 | 
  32 | // ES-5 15.3.4.5
  33 | // http://es5.github.com/#x15.3.4.5
  34 | 
  35 | function Empty() {}
  36 | 
  37 | if (!Function.prototype.bind) {
  38 |     Function.prototype.bind = function bind(that) { // .length is 1
  39 |         // 1. Let Target be the this value.
  40 |         var target = this;
  41 |         // 2. If IsCallable(Target) is false, throw a TypeError exception.
  42 |         if (typeof target != "function") {
  43 |             throw new TypeError("Function.prototype.bind called on incompatible " + target);
  44 |         }
  45 |         // 3. Let A be a new (possibly empty) internal list of all of the
  46 |         //   argument values provided after thisArg (arg1, arg2 etc), in order.
  47 |         // XXX slicedArgs will stand in for "A" if used
  48 |         var args = _Array_slice_.call(arguments, 1); // for normal call
  49 |         // 4. Let F be a new native ECMAScript object.
  50 |         // 11. Set the [[Prototype]] internal property of F to the standard
  51 |         //   built-in Function prototype object as specified in 15.3.3.1.
  52 |         // 12. Set the [[Call]] internal property of F as described in
  53 |         //   15.3.4.5.1.
  54 |         // 13. Set the [[Construct]] internal property of F as described in
  55 |         //   15.3.4.5.2.
  56 |         // 14. Set the [[HasInstance]] internal property of F as described in
  57 |         //   15.3.4.5.3.
  58 |         var bound = function () {
  59 | 
  60 |             if (this instanceof bound) {
  61 |                 // 15.3.4.5.2 [[Construct]]
  62 |                 // When the [[Construct]] internal method of a function object,
  63 |                 // F that was created using the bind function is called with a
  64 |                 // list of arguments ExtraArgs, the following steps are taken:
  65 |                 // 1. Let target be the value of F's [[TargetFunction]]
  66 |                 //   internal property.
  67 |                 // 2. If target has no [[Construct]] internal method, a
  68 |                 //   TypeError exception is thrown.
  69 |                 // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
  70 |                 //   property.
  71 |                 // 4. Let args be a new list containing the same values as the
  72 |                 //   list boundArgs in the same order followed by the same
  73 |                 //   values as the list ExtraArgs in the same order.
  74 |                 // 5. Return the result of calling the [[Construct]] internal
  75 |                 //   method of target providing args as the arguments.
  76 | 
  77 |                 var result = target.apply(
  78 |                     this,
  79 |                     args.concat(_Array_slice_.call(arguments))
  80 |                 );
  81 |                 if (Object(result) === result) {
  82 |                     return result;
  83 |                 }
  84 |                 return this;
  85 | 
  86 |             } else {
  87 |                 // 15.3.4.5.1 [[Call]]
  88 |                 // When the [[Call]] internal method of a function object, F,
  89 |                 // which was created using the bind function is called with a
  90 |                 // this value and a list of arguments ExtraArgs, the following
  91 |                 // steps are taken:
  92 |                 // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
  93 |                 //   property.
  94 |                 // 2. Let boundThis be the value of F's [[BoundThis]] internal
  95 |                 //   property.
  96 |                 // 3. Let target be the value of F's [[TargetFunction]] internal
  97 |                 //   property.
  98 |                 // 4. Let args be a new list containing the same values as the
  99 |                 //   list boundArgs in the same order followed by the same
 100 |                 //   values as the list ExtraArgs in the same order.
 101 |                 // 5. Return the result of calling the [[Call]] internal method
 102 |                 //   of target providing boundThis as the this value and
 103 |                 //   providing args as the arguments.
 104 | 
 105 |                 // equiv: target.call(this, ...boundArgs, ...args)
 106 |                 return target.apply(
 107 |                     that,
 108 |                     args.concat(_Array_slice_.call(arguments))
 109 |                 );
 110 | 
 111 |             }
 112 | 
 113 |         };
 114 |         if(target.prototype) {
 115 |             Empty.prototype = target.prototype;
 116 |             bound.prototype = new Empty();
 117 |             // Clean up dangling references.
 118 |             Empty.prototype = null;
 119 |         }
 120 |         // XXX bound.length is never writable, so don't even try
 121 |         //
 122 |         // 15. If the [[Class]] internal property of Target is "Function", then
 123 |         //     a. Let L be the length property of Target minus the length of A.
 124 |         //     b. Set the length own property of F to either 0 or L, whichever is
 125 |         //       larger.
 126 |         // 16. Else set the length own property of F to 0.
 127 |         // 17. Set the attributes of the length own property of F to the values
 128 |         //   specified in 15.3.5.1.
 129 | 
 130 |         // TODO
 131 |         // 18. Set the [[Extensible]] internal property of F to true.
 132 | 
 133 |         // TODO
 134 |         // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
 135 |         // 20. Call the [[DefineOwnProperty]] internal method of F with
 136 |         //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
 137 |         //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
 138 |         //   false.
 139 |         // 21. Call the [[DefineOwnProperty]] internal method of F with
 140 |         //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
 141 |         //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
 142 |         //   and false.
 143 | 
 144 |         // TODO
 145 |         // NOTE Function objects created using Function.prototype.bind do not
 146 |         // have a prototype property or the [[Code]], [[FormalParameters]], and
 147 |         // [[Scope]] internal properties.
 148 |         // XXX can't delete prototype in pure-js.
 149 | 
 150 |         // 22. Return F.
 151 |         return bound;
 152 |     };
 153 | }
 154 | 
 155 | // Shortcut to an often accessed properties, in order to avoid multiple
 156 | // dereference that costs universally.
 157 | // _Please note: Shortcuts are defined after `Function.prototype.bind` as we
 158 | // us it in defining shortcuts.
 159 | var call = Function.prototype.call;
 160 | var prototypeOfArray = Array.prototype;
 161 | var prototypeOfObject = Object.prototype;
 162 | var _Array_slice_ = prototypeOfArray.slice;
 163 | // Having a toString local variable name breaks in Opera so use _toString.
 164 | var _toString = call.bind(prototypeOfObject.toString);
 165 | var owns = call.bind(prototypeOfObject.hasOwnProperty);
 166 | 
 167 | // If JS engine supports accessors creating shortcuts.
 168 | var defineGetter;
 169 | var defineSetter;
 170 | var lookupGetter;
 171 | var lookupSetter;
 172 | var supportsAccessors;
 173 | if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
 174 |     defineGetter = call.bind(prototypeOfObject.__defineGetter__);
 175 |     defineSetter = call.bind(prototypeOfObject.__defineSetter__);
 176 |     lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
 177 |     lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
 178 | }
 179 | 
 180 | //
 181 | // Array
 182 | // =====
 183 | //
 184 | 
 185 | // ES5 15.4.4.12
 186 | // http://es5.github.com/#x15.4.4.12
 187 | // Default value for second param
 188 | // [bugfix, ielt9, old browsers]
 189 | // IE < 9 bug: [1,2].splice(0).join("") == "" but should be "12"
 190 | if ([1,2].splice(0).length != 2) {
 191 |     var array_splice = Array.prototype.splice;
 192 | 
 193 |     if(function() { // test IE < 9 to splice bug - see issue #138
 194 |         function makeArray(l) {
 195 |             var a = [];
 196 |             while (l--) {
 197 |                 a.unshift(l)
 198 |             }
 199 |             return a
 200 |         }
 201 | 
 202 |         var array = []
 203 |             , lengthBefore
 204 |         ;
 205 | 
 206 |         array.splice.bind(array, 0, 0).apply(null, makeArray(20));
 207 |         array.splice.bind(array, 0, 0).apply(null, makeArray(26));
 208 | 
 209 |         lengthBefore = array.length; //20
 210 |         array.splice(5, 0, "XXX"); // add one element
 211 | 
 212 |         if(lengthBefore + 1 == array.length) {
 213 |             return true;// has right splice implementation without bugs
 214 |         }
 215 |         // else {
 216 |         //    IE8 bug
 217 |         // }
 218 |     }()) {//IE 6/7
 219 |         Array.prototype.splice = function(start, deleteCount) {
 220 |             if (!arguments.length) {
 221 |                 return [];
 222 |             } else {
 223 |                 return array_splice.apply(this, [
 224 |                     start === void 0 ? 0 : start,
 225 |                     deleteCount === void 0 ? (this.length - start) : deleteCount
 226 |                 ].concat(_Array_slice_.call(arguments, 2)))
 227 |             }
 228 |         };
 229 |     }
 230 |     else {//IE8
 231 |         Array.prototype.splice = function(start, deleteCount) {
 232 |             var result
 233 |                 , args = _Array_slice_.call(arguments, 2)
 234 |                 , addElementsCount = args.length
 235 |             ;
 236 | 
 237 |             if(!arguments.length) {
 238 |                 return [];
 239 |             }
 240 | 
 241 |             if(start === void 0) { // default
 242 |                 start = 0;
 243 |             }
 244 |             if(deleteCount === void 0) { // default
 245 |                 deleteCount = this.length - start;
 246 |             }
 247 | 
 248 |             if(addElementsCount > 0) {
 249 |                 if(deleteCount <= 0) {
 250 |                     if(start == this.length) { // tiny optimisation #1
 251 |                         this.push.apply(this, args);
 252 |                         return [];
 253 |                     }
 254 | 
 255 |                     if(start == 0) { // tiny optimisation #2
 256 |                         this.unshift.apply(this, args);
 257 |                         return [];
 258 |                     }
 259 |                 }
 260 | 
 261 |                 // Array.prototype.splice implementation
 262 |                 result = _Array_slice_.call(this, start, start + deleteCount);// delete part
 263 |                 args.push.apply(args, _Array_slice_.call(this, start + deleteCount, this.length));// right part
 264 |                 args.unshift.apply(args, _Array_slice_.call(this, 0, start));// left part
 265 | 
 266 |                 // delete all items from this array and replace it to 'left part' + _Array_slice_.call(arguments, 2) + 'right part'
 267 |                 args.unshift(0, this.length);
 268 | 
 269 |                 array_splice.apply(this, args);
 270 | 
 271 |                 return result;
 272 |             }
 273 | 
 274 |             return array_splice.call(this, start, deleteCount);
 275 |         }
 276 | 
 277 |     }
 278 | }
 279 | 
 280 | // ES5 15.4.4.12
 281 | // http://es5.github.com/#x15.4.4.13
 282 | // Return len+argCount.
 283 | // [bugfix, ielt8]
 284 | // IE < 8 bug: [].unshift(0) == undefined but should be "1"
 285 | if ([].unshift(0) != 1) {
 286 |     var array_unshift = Array.prototype.unshift;
 287 |     Array.prototype.unshift = function() {
 288 |         array_unshift.apply(this, arguments);
 289 |         return this.length;
 290 |     };
 291 | }
 292 | 
 293 | // ES5 15.4.3.2
 294 | // http://es5.github.com/#x15.4.3.2
 295 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
 296 | if (!Array.isArray) {
 297 |     Array.isArray = function isArray(obj) {
 298 |         return _toString(obj) == "[object Array]";
 299 |     };
 300 | }
 301 | 
 302 | // The IsCallable() check in the Array functions
 303 | // has been replaced with a strict check on the
 304 | // internal class of the object to trap cases where
 305 | // the provided function was actually a regular
 306 | // expression literal, which in V8 and
 307 | // JavaScriptCore is a typeof "function".  Only in
 308 | // V8 are regular expression literals permitted as
 309 | // reduce parameters, so it is desirable in the
 310 | // general case for the shim to match the more
 311 | // strict and common behavior of rejecting regular
 312 | // expressions.
 313 | 
 314 | // ES5 15.4.4.18
 315 | // http://es5.github.com/#x15.4.4.18
 316 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
 317 | 
 318 | // Check failure of by-index access of string characters (IE < 9)
 319 | // and failure of `0 in boxedString` (Rhino)
 320 | var boxedString = Object("a"),
 321 |     splitString = boxedString[0] != "a" || !(0 in boxedString);
 322 | 
 323 | if (!Array.prototype.forEach) {
 324 |     Array.prototype.forEach = function forEach(fun /*, thisp*/) {
 325 |         var object = toObject(this),
 326 |             self = splitString && _toString(this) == "[object String]" ?
 327 |                 this.split("") :
 328 |                 object,
 329 |             thisp = arguments[1],
 330 |             i = -1,
 331 |             length = self.length >>> 0;
 332 | 
 333 |         // If no callback function or if callback is not a callable function
 334 |         if (_toString(fun) != "[object Function]") {
 335 |             throw new TypeError(); // TODO message
 336 |         }
 337 | 
 338 |         while (++i < length) {
 339 |             if (i in self) {
 340 |                 // Invoke the callback function with call, passing arguments:
 341 |                 // context, property value, property key, thisArg object
 342 |                 // context
 343 |                 fun.call(thisp, self[i], i, object);
 344 |             }
 345 |         }
 346 |     };
 347 | }
 348 | 
 349 | // ES5 15.4.4.19
 350 | // http://es5.github.com/#x15.4.4.19
 351 | // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
 352 | if (!Array.prototype.map) {
 353 |     Array.prototype.map = function map(fun /*, thisp*/) {
 354 |         var object = toObject(this),
 355 |             self = splitString && _toString(this) == "[object String]" ?
 356 |                 this.split("") :
 357 |                 object,
 358 |             length = self.length >>> 0,
 359 |             result = Array(length),
 360 |             thisp = arguments[1];
 361 | 
 362 |         // If no callback function or if callback is not a callable function
 363 |         if (_toString(fun) != "[object Function]") {
 364 |             throw new TypeError(fun + " is not a function");
 365 |         }
 366 | 
 367 |         for (var i = 0; i < length; i++) {
 368 |             if (i in self)
 369 |                 result[i] = fun.call(thisp, self[i], i, object);
 370 |         }
 371 |         return result;
 372 |     };
 373 | }
 374 | 
 375 | // ES5 15.4.4.20
 376 | // http://es5.github.com/#x15.4.4.20
 377 | // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
 378 | if (!Array.prototype.filter) {
 379 |     Array.prototype.filter = function filter(fun /*, thisp */) {
 380 |         var object = toObject(this),
 381 |             self = splitString && _toString(this) == "[object String]" ?
 382 |                 this.split("") :
 383 |                     object,
 384 |             length = self.length >>> 0,
 385 |             result = [],
 386 |             value,
 387 |             thisp = arguments[1];
 388 | 
 389 |         // If no callback function or if callback is not a callable function
 390 |         if (_toString(fun) != "[object Function]") {
 391 |             throw new TypeError(fun + " is not a function");
 392 |         }
 393 | 
 394 |         for (var i = 0; i < length; i++) {
 395 |             if (i in self) {
 396 |                 value = self[i];
 397 |                 if (fun.call(thisp, value, i, object)) {
 398 |                     result.push(value);
 399 |                 }
 400 |             }
 401 |         }
 402 |         return result;
 403 |     };
 404 | }
 405 | 
 406 | // ES5 15.4.4.16
 407 | // http://es5.github.com/#x15.4.4.16
 408 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every
 409 | if (!Array.prototype.every) {
 410 |     Array.prototype.every = function every(fun /*, thisp */) {
 411 |         var object = toObject(this),
 412 |             self = splitString && _toString(this) == "[object String]" ?
 413 |                 this.split("") :
 414 |                 object,
 415 |             length = self.length >>> 0,
 416 |             thisp = arguments[1];
 417 | 
 418 |         // If no callback function or if callback is not a callable function
 419 |         if (_toString(fun) != "[object Function]") {
 420 |             throw new TypeError(fun + " is not a function");
 421 |         }
 422 | 
 423 |         for (var i = 0; i < length; i++) {
 424 |             if (i in self && !fun.call(thisp, self[i], i, object)) {
 425 |                 return false;
 426 |             }
 427 |         }
 428 |         return true;
 429 |     };
 430 | }
 431 | 
 432 | // ES5 15.4.4.17
 433 | // http://es5.github.com/#x15.4.4.17
 434 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
 435 | if (!Array.prototype.some) {
 436 |     Array.prototype.some = function some(fun /*, thisp */) {
 437 |         var object = toObject(this),
 438 |             self = splitString && _toString(this) == "[object String]" ?
 439 |                 this.split("") :
 440 |                 object,
 441 |             length = self.length >>> 0,
 442 |             thisp = arguments[1];
 443 | 
 444 |         // If no callback function or if callback is not a callable function
 445 |         if (_toString(fun) != "[object Function]") {
 446 |             throw new TypeError(fun + " is not a function");
 447 |         }
 448 | 
 449 |         for (var i = 0; i < length; i++) {
 450 |             if (i in self && fun.call(thisp, self[i], i, object)) {
 451 |                 return true;
 452 |             }
 453 |         }
 454 |         return false;
 455 |     };
 456 | }
 457 | 
 458 | // ES5 15.4.4.21
 459 | // http://es5.github.com/#x15.4.4.21
 460 | // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
 461 | if (!Array.prototype.reduce) {
 462 |     Array.prototype.reduce = function reduce(fun /*, initial*/) {
 463 |         var object = toObject(this),
 464 |             self = splitString && _toString(this) == "[object String]" ?
 465 |                 this.split("") :
 466 |                 object,
 467 |             length = self.length >>> 0;
 468 | 
 469 |         // If no callback function or if callback is not a callable function
 470 |         if (_toString(fun) != "[object Function]") {
 471 |             throw new TypeError(fun + " is not a function");
 472 |         }
 473 | 
 474 |         // no value to return if no initial value and an empty array
 475 |         if (!length && arguments.length == 1) {
 476 |             throw new TypeError("reduce of empty array with no initial value");
 477 |         }
 478 | 
 479 |         var i = 0;
 480 |         var result;
 481 |         if (arguments.length >= 2) {
 482 |             result = arguments[1];
 483 |         } else {
 484 |             do {
 485 |                 if (i in self) {
 486 |                     result = self[i++];
 487 |                     break;
 488 |                 }
 489 | 
 490 |                 // if array contains no values, no initial value to return
 491 |                 if (++i >= length) {
 492 |                     throw new TypeError("reduce of empty array with no initial value");
 493 |                 }
 494 |             } while (true);
 495 |         }
 496 | 
 497 |         for (; i < length; i++) {
 498 |             if (i in self) {
 499 |                 result = fun.call(void 0, result, self[i], i, object);
 500 |             }
 501 |         }
 502 | 
 503 |         return result;
 504 |     };
 505 | }
 506 | 
 507 | // ES5 15.4.4.22
 508 | // http://es5.github.com/#x15.4.4.22
 509 | // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
 510 | if (!Array.prototype.reduceRight) {
 511 |     Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
 512 |         var object = toObject(this),
 513 |             self = splitString && _toString(this) == "[object String]" ?
 514 |                 this.split("") :
 515 |                 object,
 516 |             length = self.length >>> 0;
 517 | 
 518 |         // If no callback function or if callback is not a callable function
 519 |         if (_toString(fun) != "[object Function]") {
 520 |             throw new TypeError(fun + " is not a function");
 521 |         }
 522 | 
 523 |         // no value to return if no initial value, empty array
 524 |         if (!length && arguments.length == 1) {
 525 |             throw new TypeError("reduceRight of empty array with no initial value");
 526 |         }
 527 | 
 528 |         var result, i = length - 1;
 529 |         if (arguments.length >= 2) {
 530 |             result = arguments[1];
 531 |         } else {
 532 |             do {
 533 |                 if (i in self) {
 534 |                     result = self[i--];
 535 |                     break;
 536 |                 }
 537 | 
 538 |                 // if array contains no values, no initial value to return
 539 |                 if (--i < 0) {
 540 |                     throw new TypeError("reduceRight of empty array with no initial value");
 541 |                 }
 542 |             } while (true);
 543 |         }
 544 | 
 545 |         if (i < 0) {
 546 |             return result;
 547 |         }
 548 | 
 549 |         do {
 550 |             if (i in this) {
 551 |                 result = fun.call(void 0, result, self[i], i, object);
 552 |             }
 553 |         } while (i--);
 554 | 
 555 |         return result;
 556 |     };
 557 | }
 558 | 
 559 | // ES5 15.4.4.14
 560 | // http://es5.github.com/#x15.4.4.14
 561 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
 562 | if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) != -1)) {
 563 |     Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {
 564 |         var self = splitString && _toString(this) == "[object String]" ?
 565 |                 this.split("") :
 566 |                 toObject(this),
 567 |             length = self.length >>> 0;
 568 | 
 569 |         if (!length) {
 570 |             return -1;
 571 |         }
 572 | 
 573 |         var i = 0;
 574 |         if (arguments.length > 1) {
 575 |             i = toInteger(arguments[1]);
 576 |         }
 577 | 
 578 |         // handle negative indices
 579 |         i = i >= 0 ? i : Math.max(0, length + i);
 580 |         for (; i < length; i++) {
 581 |             if (i in self && self[i] === sought) {
 582 |                 return i;
 583 |             }
 584 |         }
 585 |         return -1;
 586 |     };
 587 | }
 588 | 
 589 | // ES5 15.4.4.15
 590 | // http://es5.github.com/#x15.4.4.15
 591 | // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf
 592 | if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) != -1)) {
 593 |     Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {
 594 |         var self = splitString && _toString(this) == "[object String]" ?
 595 |                 this.split("") :
 596 |                 toObject(this),
 597 |             length = self.length >>> 0;
 598 | 
 599 |         if (!length) {
 600 |             return -1;
 601 |         }
 602 |         var i = length - 1;
 603 |         if (arguments.length > 1) {
 604 |             i = Math.min(i, toInteger(arguments[1]));
 605 |         }
 606 |         // handle negative indices
 607 |         i = i >= 0 ? i : length - Math.abs(i);
 608 |         for (; i >= 0; i--) {
 609 |             if (i in self && sought === self[i]) {
 610 |                 return i;
 611 |             }
 612 |         }
 613 |         return -1;
 614 |     };
 615 | }
 616 | 
 617 | //
 618 | // Object
 619 | // ======
 620 | //
 621 | 
 622 | // ES5 15.2.3.14
 623 | // http://es5.github.com/#x15.2.3.14
 624 | if (!Object.keys) {
 625 |     // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
 626 |     var hasDontEnumBug = true,
 627 |         dontEnums = [
 628 |             "toString",
 629 |             "toLocaleString",
 630 |             "valueOf",
 631 |             "hasOwnProperty",
 632 |             "isPrototypeOf",
 633 |             "propertyIsEnumerable",
 634 |             "constructor"
 635 |         ],
 636 |         dontEnumsLength = dontEnums.length;
 637 | 
 638 |     for (var key in {"toString": null}) {
 639 |         hasDontEnumBug = false;
 640 |     }
 641 | 
 642 |     Object.keys = function keys(object) {
 643 | 
 644 |         if (
 645 |             (typeof object != "object" && typeof object != "function") ||
 646 |             object === null
 647 |         ) {
 648 |             throw new TypeError("Object.keys called on a non-object");
 649 |         }
 650 | 
 651 |         var keys = [];
 652 |         for (var name in object) {
 653 |             if (owns(object, name)) {
 654 |                 keys.push(name);
 655 |             }
 656 |         }
 657 | 
 658 |         if (hasDontEnumBug) {
 659 |             for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
 660 |                 var dontEnum = dontEnums[i];
 661 |                 if (owns(object, dontEnum)) {
 662 |                     keys.push(dontEnum);
 663 |                 }
 664 |             }
 665 |         }
 666 |         return keys;
 667 |     };
 668 | 
 669 | }
 670 | 
 671 | //
 672 | // Date
 673 | // ====
 674 | //
 675 | 
 676 | // ES5 15.9.5.43
 677 | // http://es5.github.com/#x15.9.5.43
 678 | // This function returns a String value represent the instance in time
 679 | // represented by this Date object. The format of the String is the Date Time
 680 | // string format defined in 15.9.1.15. All fields are present in the String.
 681 | // The time zone is always UTC, denoted by the suffix Z. If the time value of
 682 | // this object is not a finite Number a RangeError exception is thrown.
 683 | var negativeDate = -62198755200000,
 684 |     negativeYearString = "-000001";
 685 | if (
 686 |     !Date.prototype.toISOString ||
 687 |     (new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1)
 688 | ) {
 689 |     Date.prototype.toISOString = function toISOString() {
 690 |         var result, length, value, year, month;
 691 |         if (!isFinite(this)) {
 692 |             throw new RangeError("Date.prototype.toISOString called on non-finite value.");
 693 |         }
 694 | 
 695 |         year = this.getUTCFullYear();
 696 | 
 697 |         month = this.getUTCMonth();
 698 |         // see https://github.com/kriskowal/es5-shim/issues/111
 699 |         year += Math.floor(month / 12);
 700 |         month = (month % 12 + 12) % 12;
 701 | 
 702 |         // the date time string format is specified in 15.9.1.15.
 703 |         result = [month + 1, this.getUTCDate(),
 704 |             this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()];
 705 |         year = (
 706 |             (year < 0 ? "-" : (year > 9999 ? "+" : "")) +
 707 |             ("00000" + Math.abs(year))
 708 |             .slice(0 <= year && year <= 9999 ? -4 : -6)
 709 |         );
 710 | 
 711 |         length = result.length;
 712 |         while (length--) {
 713 |             value = result[length];
 714 |             // pad months, days, hours, minutes, and seconds to have two
 715 |             // digits.
 716 |             if (value < 10) {
 717 |                 result[length] = "0" + value;
 718 |             }
 719 |         }
 720 |         // pad milliseconds to have three digits.
 721 |         return (
 722 |             year + "-" + result.slice(0, 2).join("-") +
 723 |             "T" + result.slice(2).join(":") + "." +
 724 |             ("000" + this.getUTCMilliseconds()).slice(-3) + "Z"
 725 |         );
 726 |     };
 727 | }
 728 | 
 729 | 
 730 | // ES5 15.9.5.44
 731 | // http://es5.github.com/#x15.9.5.44
 732 | // This function provides a String representation of a Date object for use by
 733 | // JSON.stringify (15.12.3).
 734 | var dateToJSONIsSupported = false;
 735 | try {
 736 |     dateToJSONIsSupported = (
 737 |         Date.prototype.toJSON &&
 738 |         new Date(NaN).toJSON() === null &&
 739 |         new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 &&
 740 |         Date.prototype.toJSON.call({ // generic
 741 |             toISOString: function () {
 742 |                 return true;
 743 |             }
 744 |         })
 745 |     );
 746 | } catch (e) {
 747 | }
 748 | if (!dateToJSONIsSupported) {
 749 |     Date.prototype.toJSON = function toJSON(key) {
 750 |         // When the toJSON method is called with argument key, the following
 751 |         // steps are taken:
 752 | 
 753 |         // 1.  Let O be the result of calling ToObject, giving it the this
 754 |         // value as its argument.
 755 |         // 2. Let tv be toPrimitive(O, hint Number).
 756 |         var o = Object(this),
 757 |             tv = toPrimitive(o),
 758 |             toISO;
 759 |         // 3. If tv is a Number and is not finite, return null.
 760 |         if (typeof tv === "number" && !isFinite(tv)) {
 761 |             return null;
 762 |         }
 763 |         // 4. Let toISO be the result of calling the [[Get]] internal method of
 764 |         // O with argument "toISOString".
 765 |         toISO = o.toISOString;
 766 |         // 5. If IsCallable(toISO) is false, throw a TypeError exception.
 767 |         if (typeof toISO != "function") {
 768 |             throw new TypeError("toISOString property is not callable");
 769 |         }
 770 |         // 6. Return the result of calling the [[Call]] internal method of
 771 |         //  toISO with O as the this value and an empty argument list.
 772 |         return toISO.call(o);
 773 | 
 774 |         // NOTE 1 The argument is ignored.
 775 | 
 776 |         // NOTE 2 The toJSON function is intentionally generic; it does not
 777 |         // require that its this value be a Date object. Therefore, it can be
 778 |         // transferred to other kinds of objects for use as a method. However,
 779 |         // it does require that any such object have a toISOString method. An
 780 |         // object is free to use the argument key to filter its
 781 |         // stringification.
 782 |     };
 783 | }
 784 | 
 785 | // ES5 15.9.4.2
 786 | // http://es5.github.com/#x15.9.4.2
 787 | // based on work shared by Daniel Friesen (dantman)
 788 | // http://gist.github.com/303249
 789 | if (!Date.parse || "Date.parse is buggy") {
 790 |     // XXX global assignment won't work in embeddings that use
 791 |     // an alternate object for the context.
 792 |     Date = (function(NativeDate) {
 793 | 
 794 |         // Date.length === 7
 795 |         function Date(Y, M, D, h, m, s, ms) {
 796 |             var length = arguments.length;
 797 |             if (this instanceof NativeDate) {
 798 |                 var date = length == 1 && String(Y) === Y ? // isString(Y)
 799 |                     // We explicitly pass it through parse:
 800 |                     new NativeDate(Date.parse(Y)) :
 801 |                     // We have to manually make calls depending on argument
 802 |                     // length here
 803 |                     length >= 7 ? new NativeDate(Y, M, D, h, m, s, ms) :
 804 |                     length >= 6 ? new NativeDate(Y, M, D, h, m, s) :
 805 |                     length >= 5 ? new NativeDate(Y, M, D, h, m) :
 806 |                     length >= 4 ? new NativeDate(Y, M, D, h) :
 807 |                     length >= 3 ? new NativeDate(Y, M, D) :
 808 |                     length >= 2 ? new NativeDate(Y, M) :
 809 |                     length >= 1 ? new NativeDate(Y) :
 810 |                                   new NativeDate();
 811 |                 // Prevent mixups with unfixed Date object
 812 |                 date.constructor = Date;
 813 |                 return date;
 814 |             }
 815 |             return NativeDate.apply(this, arguments);
 816 |         };
 817 | 
 818 |         // 15.9.1.15 Date Time String Format.
 819 |         var isoDateExpression = new RegExp("^" +
 820 |             "(\\d{4}|[\+\-]\\d{6})" + // four-digit year capture or sign +
 821 |                                       // 6-digit extended year
 822 |             "(?:-(\\d{2})" + // optional month capture
 823 |             "(?:-(\\d{2})" + // optional day capture
 824 |             "(?:" + // capture hours:minutes:seconds.milliseconds
 825 |                 "T(\\d{2})" + // hours capture
 826 |                 ":(\\d{2})" + // minutes capture
 827 |                 "(?:" + // optional :seconds.milliseconds
 828 |                     ":(\\d{2})" + // seconds capture
 829 |                     "(?:(\\.\\d{1,}))?" + // milliseconds capture
 830 |                 ")?" +
 831 |             "(" + // capture UTC offset component
 832 |                 "Z|" + // UTC capture
 833 |                 "(?:" + // offset specifier +/-hours:minutes
 834 |                     "([-+])" + // sign capture
 835 |                     "(\\d{2})" + // hours offset capture
 836 |                     ":(\\d{2})" + // minutes offset capture
 837 |                 ")" +
 838 |             ")?)?)?)?" +
 839 |         "$");
 840 | 
 841 |         var months = [
 842 |             0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
 843 |         ];
 844 | 
 845 |         function dayFromMonth(year, month) {
 846 |             var t = month > 1 ? 1 : 0;
 847 |             return (
 848 |                 months[month] +
 849 |                 Math.floor((year - 1969 + t) / 4) -
 850 |                 Math.floor((year - 1901 + t) / 100) +
 851 |                 Math.floor((year - 1601 + t) / 400) +
 852 |                 365 * (year - 1970)
 853 |             );
 854 |         }
 855 | 
 856 |         // Copy any custom methods a 3rd party library may have added
 857 |         for (var key in NativeDate) {
 858 |             Date[key] = NativeDate[key];
 859 |         }
 860 | 
 861 |         // Copy "native" methods explicitly; they may be non-enumerable
 862 |         Date.now = NativeDate.now;
 863 |         Date.UTC = NativeDate.UTC;
 864 |         Date.prototype = NativeDate.prototype;
 865 |         Date.prototype.constructor = Date;
 866 | 
 867 |         // Upgrade Date.parse to handle simplified ISO 8601 strings
 868 |         Date.parse = function parse(string) {
 869 |             var match = isoDateExpression.exec(string);
 870 |             if (match) {
 871 |                 // parse months, days, hours, minutes, seconds, and milliseconds
 872 |                 // provide default values if necessary
 873 |                 // parse the UTC offset component
 874 |                 var year = Number(match[1]),
 875 |                     month = Number(match[2] || 1) - 1,
 876 |                     day = Number(match[3] || 1) - 1,
 877 |                     hour = Number(match[4] || 0),
 878 |                     minute = Number(match[5] || 0),
 879 |                     second = Number(match[6] || 0),
 880 |                     millisecond = Math.floor(Number(match[7] || 0) * 1000),
 881 |                     // When time zone is missed, local offset should be used
 882 |                     // (ES 5.1 bug)
 883 |                     // see https://bugs.ecmascript.org/show_bug.cgi?id=112
 884 |                     offset = !match[4] || match[8] ?
 885 |                         0 : Number(new NativeDate(1970, 0)),
 886 |                     signOffset = match[9] === "-" ? 1 : -1,
 887 |                     hourOffset = Number(match[10] || 0),
 888 |                     minuteOffset = Number(match[11] || 0),
 889 |                     result;
 890 |                 if (
 891 |                     hour < (
 892 |                         minute > 0 || second > 0 || millisecond > 0 ?
 893 |                         24 : 25
 894 |                     ) &&
 895 |                     minute < 60 && second < 60 && millisecond < 1000 &&
 896 |                     month > -1 && month < 12 && hourOffset < 24 &&
 897 |                     minuteOffset < 60 && // detect invalid offsets
 898 |                     day > -1 &&
 899 |                     day < (
 900 |                         dayFromMonth(year, month + 1) -
 901 |                         dayFromMonth(year, month)
 902 |                     )
 903 |                 ) {
 904 |                     result = (
 905 |                         (dayFromMonth(year, month) + day) * 24 +
 906 |                         hour +
 907 |                         hourOffset * signOffset
 908 |                     ) * 60;
 909 |                     result = (
 910 |                         (result + minute + minuteOffset * signOffset) * 60 +
 911 |                         second
 912 |                     ) * 1000 + millisecond + offset;
 913 |                     if (-8.64e15 <= result && result <= 8.64e15) {
 914 |                         return result;
 915 |                     }
 916 |                 }
 917 |                 return NaN;
 918 |             }
 919 |             return NativeDate.parse.apply(this, arguments);
 920 |         };
 921 | 
 922 |         return Date;
 923 |     })(Date);
 924 | }
 925 | 
 926 | // ES5 15.9.4.4
 927 | // http://es5.github.com/#x15.9.4.4
 928 | if (!Date.now) {
 929 |     Date.now = function now() {
 930 |         return new Date().getTime();
 931 |     };
 932 | }
 933 | 
 934 | 
 935 | //
 936 | // Number
 937 | // ======
 938 | //
 939 | 
 940 | // ES5.1 15.7.4.5
 941 | // http://es5.github.com/#x15.7.4.5
 942 | if (!Number.prototype.toFixed || (0.00008).toFixed(3) !== '0.000' || (0.9).toFixed(0) === '0' || (1.255).toFixed(2) !== '1.25' || (1000000000000000128).toFixed(0) !== "1000000000000000128") {
 943 |     // Hide these variables and functions
 944 |     (function () {
 945 |         var base, size, data, i;
 946 | 
 947 |         base = 1e7;
 948 |         size = 6;
 949 |         data = [0, 0, 0, 0, 0, 0];
 950 | 
 951 |         function multiply(n, c) {
 952 |             var i = -1;
 953 |             while (++i < size) {
 954 |                 c += n * data[i];
 955 |                 data[i] = c % base;
 956 |                 c = Math.floor(c / base);
 957 |             }
 958 |         }
 959 | 
 960 |         function divide(n) {
 961 |             var i = size, c = 0;
 962 |             while (--i >= 0) {
 963 |                 c += data[i];
 964 |                 data[i] = Math.floor(c / n);
 965 |                 c = (c % n) * base;
 966 |             }
 967 |         }
 968 | 
 969 |         function toString() {
 970 |             var i = size;
 971 |             var s = '';
 972 |             while (--i >= 0) {
 973 |                 if (s !== '' || i === 0 || data[i] !== 0) {
 974 |                     var t = String(data[i]);
 975 |                     if (s === '') {
 976 |                         s = t;
 977 |                     } else {
 978 |                         s += '0000000'.slice(0, 7 - t.length) + t;
 979 |                     }
 980 |                 }
 981 |             }
 982 |             return s;
 983 |         }
 984 | 
 985 |         function pow(x, n, acc) {
 986 |             return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc)));
 987 |         }
 988 | 
 989 |         function log(x) {
 990 |             var n = 0;
 991 |             while (x >= 4096) {
 992 |                 n += 12;
 993 |                 x /= 4096;
 994 |             }
 995 |             while (x >= 2) {
 996 |                 n += 1;
 997 |                 x /= 2;
 998 |             }
 999 |             return n;
1000 |         }
1001 | 
1002 |         Number.prototype.toFixed = function (fractionDigits) {
1003 |             var f, x, s, m, e, z, j, k;
1004 | 
1005 |             // Test for NaN and round fractionDigits down
1006 |             f = Number(fractionDigits);
1007 |             f = f !== f ? 0 : Math.floor(f);
1008 | 
1009 |             if (f < 0 || f > 20) {
1010 |                 throw new RangeError("Number.toFixed called with invalid number of decimals");
1011 |             }
1012 | 
1013 |             x = Number(this);
1014 | 
1015 |             // Test for NaN
1016 |             if (x !== x) {
1017 |                 return "NaN";
1018 |             }
1019 | 
1020 |             // If it is too big or small, return the string value of the number
1021 |             if (x <= -1e21 || x >= 1e21) {
1022 |                 return String(x);
1023 |             }
1024 | 
1025 |             s = "";
1026 | 
1027 |             if (x < 0) {
1028 |                 s = "-";
1029 |                 x = -x;
1030 |             }
1031 | 
1032 |             m = "0";
1033 | 
1034 |             if (x > 1e-21) {
1035 |                 // 1e-21 < x < 1e21
1036 |                 // -70 < log2(x) < 70
1037 |                 e = log(x * pow(2, 69, 1)) - 69;
1038 |                 z = (e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1));
1039 |                 z *= 0x10000000000000; // Math.pow(2, 52);
1040 |                 e = 52 - e;
1041 | 
1042 |                 // -18 < e < 122
1043 |                 // x = z / 2 ^ e
1044 |                 if (e > 0) {
1045 |                     multiply(0, z);
1046 |                     j = f;
1047 | 
1048 |                     while (j >= 7) {
1049 |                         multiply(1e7, 0);
1050 |                         j -= 7;
1051 |                     }
1052 | 
1053 |                     multiply(pow(10, j, 1), 0);
1054 |                     j = e - 1;
1055 | 
1056 |                     while (j >= 23) {
1057 |                         divide(1 << 23);
1058 |                         j -= 23;
1059 |                     }
1060 | 
1061 |                     divide(1 << j);
1062 |                     multiply(1, 1);
1063 |                     divide(2);
1064 |                     m = toString();
1065 |                 } else {
1066 |                     multiply(0, z);
1067 |                     multiply(1 << (-e), 0);
1068 |                     m = toString() + '0.00000000000000000000'.slice(2, 2 + f);
1069 |                 }
1070 |             }
1071 | 
1072 |             if (f > 0) {
1073 |                 k = m.length;
1074 | 
1075 |                 if (k <= f) {
1076 |                     m = s + '0.0000000000000000000'.slice(0, f - k + 2) + m;
1077 |                 } else {
1078 |                     m = s + m.slice(0, k - f) + '.' + m.slice(k - f);
1079 |                 }
1080 |             } else {
1081 |                 m = s + m;
1082 |             }
1083 | 
1084 |             return m;
1085 |         }
1086 |     }());
1087 | }
1088 | 
1089 | 
1090 | //
1091 | // String
1092 | // ======
1093 | //
1094 | 
1095 | 
1096 | // ES5 15.5.4.14
1097 | // http://es5.github.com/#x15.5.4.14
1098 | 
1099 | // [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers]
1100 | // Many browsers do not split properly with regular expressions or they
1101 | // do not perform the split correctly under obscure conditions.
1102 | // See http://blog.stevenlevithan.com/archives/cross-browser-split
1103 | // I've tested in many browsers and this seems to cover the deviant ones:
1104 | //    'ab'.split(/(?:ab)*/) should be ["", ""], not [""]
1105 | //    '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""]
1106 | //    'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not
1107 | //       [undefined, "t", undefined, "e", ...]
1108 | //    ''.split(/.?/) should be [], not [""]
1109 | //    '.'.split(/()()/) should be ["."], not ["", "", "."]
1110 | 
1111 | var string_split = String.prototype.split;
1112 | if (
1113 |     'ab'.split(/(?:ab)*/).length !== 2 ||
1114 |     '.'.split(/(.?)(.?)/).length !== 4 ||
1115 |     'tesst'.split(/(s)*/)[1] === "t" ||
1116 |     ''.split(/.?/).length === 0 ||
1117 |     '.'.split(/()()/).length > 1
1118 | ) {
1119 |     (function () {
1120 |         var compliantExecNpcg = /()??/.exec("")[1] === void 0; // NPCG: nonparticipating capturing group
1121 | 
1122 |         String.prototype.split = function (separator, limit) {
1123 |             var string = this;
1124 |             if (separator === void 0 && limit === 0)
1125 |                 return [];
1126 | 
1127 |             // If `separator` is not a regex, use native split
1128 |             if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
1129 |                 return string_split.apply(this, arguments);
1130 |             }
1131 | 
1132 |             var output = [],
1133 |                 flags = (separator.ignoreCase ? "i" : "") +
1134 |                         (separator.multiline  ? "m" : "") +
1135 |                         (separator.extended   ? "x" : "") + // Proposed for ES6
1136 |                         (separator.sticky     ? "y" : ""), // Firefox 3+
1137 |                 lastLastIndex = 0,
1138 |                 // Make `global` and avoid `lastIndex` issues by working with a copy
1139 |                 separator = new RegExp(separator.source, flags + "g"),
1140 |                 separator2, match, lastIndex, lastLength;
1141 |             string += ""; // Type-convert
1142 |             if (!compliantExecNpcg) {
1143 |                 // Doesn't need flags gy, but they don't hurt
1144 |                 separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
1145 |             }
1146 |             /* Values for `limit`, per the spec:
1147 |              * If undefined: 4294967295 // Math.pow(2, 32) - 1
1148 |              * If 0, Infinity, or NaN: 0
1149 |              * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
1150 |              * If negative number: 4294967296 - Math.floor(Math.abs(limit))
1151 |              * If other: Type-convert, then use the above rules
1152 |              */
1153 |             limit = limit === void 0 ?
1154 |                 -1 >>> 0 : // Math.pow(2, 32) - 1
1155 |                 limit >>> 0; // ToUint32(limit)
1156 |             while (match = separator.exec(string)) {
1157 |                 // `separator.lastIndex` is not reliable cross-browser
1158 |                 lastIndex = match.index + match[0].length;
1159 |                 if (lastIndex > lastLastIndex) {
1160 |                     output.push(string.slice(lastLastIndex, match.index));
1161 |                     // Fix browsers whose `exec` methods don't consistently return `undefined` for
1162 |                     // nonparticipating capturing groups
1163 |                     if (!compliantExecNpcg && match.length > 1) {
1164 |                         match[0].replace(separator2, function () {
1165 |                             for (var i = 1; i < arguments.length - 2; i++) {
1166 |                                 if (arguments[i] === void 0) {
1167 |                                     match[i] = void 0;
1168 |                                 }
1169 |                             }
1170 |                         });
1171 |                     }
1172 |                     if (match.length > 1 && match.index < string.length) {
1173 |                         Array.prototype.push.apply(output, match.slice(1));
1174 |                     }
1175 |                     lastLength = match[0].length;
1176 |                     lastLastIndex = lastIndex;
1177 |                     if (output.length >= limit) {
1178 |                         break;
1179 |                     }
1180 |                 }
1181 |                 if (separator.lastIndex === match.index) {
1182 |                     separator.lastIndex++; // Avoid an infinite loop
1183 |                 }
1184 |             }
1185 |             if (lastLastIndex === string.length) {
1186 |                 if (lastLength || !separator.test("")) {
1187 |                     output.push("");
1188 |                 }
1189 |             } else {
1190 |                 output.push(string.slice(lastLastIndex));
1191 |             }
1192 |             return output.length > limit ? output.slice(0, limit) : output;
1193 |         };
1194 |     }());
1195 | 
1196 | // [bugfix, chrome]
1197 | // If separator is undefined, then the result array contains just one String,
1198 | // which is the this value (converted to a String). If limit is not undefined,
1199 | // then the output array is truncated so that it contains no more than limit
1200 | // elements.
1201 | // "0".split(undefined, 0) -> []
1202 | } else if ("0".split(void 0, 0).length) {
1203 |     String.prototype.split = function(separator, limit) {
1204 |         if (separator === void 0 && limit === 0) return [];
1205 |         return string_split.apply(this, arguments);
1206 |     }
1207 | }
1208 | 
1209 | 
1210 | // ECMA-262, 3rd B.2.3
1211 | // Note an ECMAScript standart, although ECMAScript 3rd Edition has a
1212 | // non-normative section suggesting uniform semantics and it should be
1213 | // normalized across all browsers
1214 | // [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE
1215 | if("".substr && "0b".substr(-1) !== "b") {
1216 |     var string_substr = String.prototype.substr;
1217 |     /**
1218 |      *  Get the substring of a string
1219 |      *  @param  {integer}  start   where to start the substring
1220 |      *  @param  {integer}  length  how many characters to return
1221 |      *  @return {string}
1222 |      */
1223 |     String.prototype.substr = function(start, length) {
1224 |         return string_substr.call(
1225 |             this,
1226 |             start < 0 ? ((start = this.length + start) < 0 ? 0 : start) : start,
1227 |             length
1228 |         );
1229 |     }
1230 | }
1231 | 
1232 | // ES5 15.5.4.20
1233 | // http://es5.github.com/#x15.5.4.20
1234 | var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
1235 |     "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" +
1236 |     "\u2029\uFEFF";
1237 | if (!String.prototype.trim || ws.trim()) {
1238 |     // http://blog.stevenlevithan.com/archives/faster-trim-javascript
1239 |     // http://perfectionkills.com/whitespace-deviations/
1240 |     ws = "[" + ws + "]";
1241 |     var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
1242 |         trimEndRegexp = new RegExp(ws + ws + "*$");
1243 |     String.prototype.trim = function trim() {
1244 |         if (this === void 0 || this === null) {
1245 |             throw new TypeError("can't convert "+this+" to object");
1246 |         }
1247 |         return String(this)
1248 |             .replace(trimBeginRegexp, "")
1249 |             .replace(trimEndRegexp, "");
1250 |     };
1251 | }
1252 | 
1253 | //
1254 | // Util
1255 | // ======
1256 | //
1257 | 
1258 | // ES5 9.4
1259 | // http://es5.github.com/#x9.4
1260 | // http://jsperf.com/to-integer
1261 | 
1262 | function toInteger(n) {
1263 |     n = +n;
1264 |     if (n !== n) { // isNaN
1265 |         n = 0;
1266 |     } else if (n !== 0 && n !== (1/0) && n !== -(1/0)) {
1267 |         n = (n > 0 || -1) * Math.floor(Math.abs(n));
1268 |     }
1269 |     return n;
1270 | }
1271 | 
1272 | function isPrimitive(input) {
1273 |     var type = typeof input;
1274 |     return (
1275 |         input === null ||
1276 |         type === "undefined" ||
1277 |         type === "boolean" ||
1278 |         type === "number" ||
1279 |         type === "string"
1280 |     );
1281 | }
1282 | 
1283 | function toPrimitive(input) {
1284 |     var val, valueOf, toString;
1285 |     if (isPrimitive(input)) {
1286 |         return input;
1287 |     }
1288 |     valueOf = input.valueOf;
1289 |     if (typeof valueOf === "function") {
1290 |         val = valueOf.call(input);
1291 |         if (isPrimitive(val)) {
1292 |             return val;
1293 |         }
1294 |     }
1295 |     toString = input.toString;
1296 |     if (typeof toString === "function") {
1297 |         val = toString.call(input);
1298 |         if (isPrimitive(val)) {
1299 |             return val;
1300 |         }
1301 |     }
1302 |     throw new TypeError();
1303 | }
1304 | 
1305 | // ES5 9.9
1306 | // http://es5.github.com/#x9.9
1307 | var toObject = function (o) {
1308 |     if (o == null) { // this matches both null and undefined
1309 |         throw new TypeError("can't convert "+o+" to object");
1310 |     }
1311 |     return Object(o);
1312 | };
1313 | 
1314 | });
1315 | 


--------------------------------------------------------------------------------
/client/js/pageController/baseMixin.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * An "abstract" base controller function.
 7 |  */
 8 | 
 9 | (function () {
10 |   'use strict';
11 |   var inheritance = angular.module('inheritance');
12 | 
13 |   /**
14 |    * An "abstract" base controller function to be used for mixin-style
15 |    * inheritance.
16 |    *
17 |    * Note that prototype functions are not inherited if using the $injector
18 |    * method of controller inheritance.
19 |    */
20 |   function BaseMixinController($scope) {
21 |     $scope.mixinControllerNames = $scope.mixinControllerNames || [];
22 |     $scope.mixinControllerNames.push('baseMixinController');
23 |   }
24 |   var p = BaseMixinController.prototype;
25 | 
26 |   /**
27 |    * A placeholder function for tests of whether prototype functions are
28 |    * preserved in inheritance.
29 |    *
30 |    * @return {boolean}
31 |    */
32 |   p.mixinPrototypeFunction = function () {
33 |     return true;
34 |   };
35 | 
36 |   inheritance.BaseMixinControllerConstructor = BaseMixinController;
37 | })();
38 | 


--------------------------------------------------------------------------------
/client/js/pageController/baseNoPrototypeFunctionality.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * An "abstract" base controller function that doesn't define functionality in
 7 |  * its prototype, but rather in the function body.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * An "abstract" base controller function that doesn't define functionality in
16 |    * its prototype, but rather in the function body.
17 |    *
18 |    * Note that function definitions must be set to allow child controllers to
19 |    * override them by specifying the function in advance of invoking this
20 |    * parent controller function. i.e.:
21 |    *
22 |    * this.fn = this.fn || function () {};
23 |    */
24 |   function BaseNoPrototypeFunctionalityController($scope) {
25 |     /**
26 |      * Set the controller name in the scope.
27 |      */
28 |     this.setControllerName = this.setControllerName || function () {
29 |       $scope.controllerName = 'alphaController';
30 |     };
31 | 
32 |     /**
33 |      * Initialize the controller. Called on instantiation.
34 |      */
35 |     this.initialize = this.initialize || function () {
36 |       this.setControllerName();
37 |     };
38 | 
39 |     this.initialize();
40 |   }
41 | 
42 |   inheritance.BaseNoPrototypeFunctionalityControllerConstructor = BaseNoPrototypeFunctionalityController;
43 | })();
44 | 


--------------------------------------------------------------------------------
/client/js/pageController/basePrototypeFunctionality.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * An "abstract" base controller function that defines functionality in
 7 |  * its prototype rather than in the function body.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * An "abstract" base controller function that defines functionality in
16 |    * its prototype rather than in the function body.
17 |    */
18 |   function BasePrototypeFunctionalityController($scope) {
19 |     this.$scope = $scope;
20 |     this.initialize();
21 |   }
22 |   var p = BasePrototypeFunctionalityController.prototype;
23 | 
24 |   /**
25 |    * Set the controller name in the scope.
26 |    */
27 |   p.setControllerName = function () {
28 |     this.$scope.controllerName = 'basePrototypeFunctionalityController';
29 |   };
30 | 
31 |   /**
32 |    * Initialize the controller. Called on instantiation.
33 |    */
34 |   p.initialize = function () {
35 |     this.setControllerName();
36 |   };
37 | 
38 |   inheritance.BasePrototypeFunctionalityControllerConstructor = BasePrototypeFunctionalityController;
39 | })();
40 | 


--------------------------------------------------------------------------------
/client/js/pageController/inheritByInjector.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * A child controller that inherits the functionality of a parent via the
 7 |  * $injector.invoke() method.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * A child controller that inherits the functionality of a parent via the
16 |    * $injector.invoke() method.
17 |    */
18 |   function InheritByInjectorController($injector, $scope) {
19 |     // Override a parent controller function. We have to do this before calling
20 |     // $injector.invoke(). But leave it open to further overriding by child
21 |     // classes.
22 |     this.setControllerName = this.setControllerName || function () {
23 |       $scope.controllerName = 'inheritByInjectorController';
24 |     };
25 | 
26 |     // Using the injector like this is not the same as prototypical inheritance.
27 |     // No prototype functions are brought over, only what is attached to (this)
28 |     // in the parent controller constructor.
29 |     $injector.invoke(inheritance.BaseNoPrototypeFunctionalityControllerConstructor, this, {
30 |       $scope: $scope
31 |     });
32 |   }
33 | 
34 |   inheritance.InheritByInjectorControllerConstructor = InheritByInjectorController;
35 |   inheritance.controller('inheritByInjectorController', [
36 |     '$injector',
37 |     '$scope',
38 |     InheritByInjectorController
39 |   ]);
40 | 
41 | })();
42 | 


--------------------------------------------------------------------------------
/client/js/pageController/inheritPrototypically.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * A child controller that inherits the functionality of a parent via standard
 7 |  * Javascript prototypical inheritance.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * A child controller that inherits the functionality of a parent via standard
16 |    * Javascript prototypical inheritance.
17 |    */
18 |   function InheritPrototypicallyController($scope) {
19 |     // We can avoid passing long argument lists explicitly by suitably ordering
20 |     // the injected dependencies. This is pleasant when the number of services
21 |     // starts growing.
22 |     InheritPrototypicallyController.super_.apply(this, arguments);
23 |   }
24 |   // See /js/app.js for the definition of inheritance.inherits().
25 |   inheritance.inherits(InheritPrototypicallyController, inheritance.BasePrototypeFunctionalityControllerConstructor);
26 |   var p = InheritPrototypicallyController.prototype;
27 | 
28 |   /**
29 |    * Override a parent method.
30 |    *
31 |    * @see BasePrototypeFunctionality#setControllerName
32 |    */
33 |   p.setControllerName = function () {
34 |     this.$scope.controllerName = 'inheritPrototypicallyController';
35 |   };
36 | 
37 |   inheritance.InheritPrototypicallyControllerConstructor = InheritPrototypicallyController;
38 |   inheritance.controller('inheritPrototypicallyController', [
39 |     '$scope',
40 |     InheritPrototypicallyController
41 |   ]);
42 | 
43 | })();
44 | 


--------------------------------------------------------------------------------
/client/js/pageController/mixinByInjector.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * A child controller that inherits from multiple parents via the $injector
 7 |  * method.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * A child controller that inherits from multiple parents via the $injector
16 |    * method.
17 |    */
18 |   function MixinByInjectorController($injector, $scope) {
19 |     var self = this;
20 |     // Override a parent controller function. We have to do this before calling
21 |     // $injector.invoke(). But leave it open to further overriding by child
22 |     // classes.
23 |     this.setControllerName = this.setControllerName || function () {
24 |       $scope.controllerName = 'mixinByInjectorController';
25 |     };
26 | 
27 |     // Decorate the scope with this detector function.
28 |     $scope.mixinPrototypeFunctionsInherited = function () {
29 |       return (typeof self.mixinPrototypeFunction === 'function');
30 |     };
31 | 
32 |     // Mixin multiple parent controllers.
33 |     $injector.invoke(inheritance.BaseMixinControllerConstructor, this, {
34 |       $scope: $scope
35 |     });
36 |     $injector.invoke(inheritance.InheritByInjectorControllerConstructor, this, {
37 |       $injector: $injector,
38 |       $scope: $scope
39 |     });
40 |   }
41 | 
42 |   inheritance.MixinByInjectorControllerConstructor = MixinByInjectorController;
43 |   inheritance.controller('mixinByInjectorController', [
44 |     '$injector',
45 |     '$scope',
46 |     MixinByInjectorController
47 |   ]);
48 | 
49 | })();
50 | 


--------------------------------------------------------------------------------
/client/js/pageController/mixinWithPrototypicalInheritance.js:
--------------------------------------------------------------------------------
 1 | /*global
 2 |   angular: false
 3 | */
 4 | /**
 5 |  * @fileOverview
 6 |  * A child controller that inherits from multiple parents via prototypical
 7 |  * inheritance for the main parent and then the addition of a mixin.
 8 |  */
 9 | 
10 | (function () {
11 |   'use strict';
12 |   var inheritance = angular.module('inheritance');
13 | 
14 |   /**
15 |    * A child controller that inherits from multiple parents via prototypical
16 |    * inheritance for the main parent and then the addition of a mixin.
17 |    */
18 |   function MixinWithPrototypicalInheritanceController($scope) {
19 |     // We can avoid passing long argument lists explicitly by suitably ordering
20 |     // the injected dependencies. This is pleasant when the number of services
21 |     // starts growing.
22 |     MixinWithPrototypicalInheritanceController.super_.apply(this, arguments);
23 |     // Also run the mixin constructor. Here it's only a coincidence that the
24 |     // signatures match. You are most likely to have to explicitly declare the
25 |     // dependences in the method signature.
26 |     inheritance.BaseMixinControllerConstructor.call(this, $scope);
27 |   }
28 |   // See /js/app.js for the definition of inheritance.inherits().
29 |   inheritance.inherits(MixinWithPrototypicalInheritanceController, inheritance.InheritPrototypicallyControllerConstructor);
30 |   var p = MixinWithPrototypicalInheritanceController.prototype;
31 | 
32 |   // Add the mixin prototype functionality to the ChildController prototype,
33 |   // provided it doesn't already exist - i.e. is overridden.
34 |   angular.forEach(inheritance.BaseMixinControllerConstructor.prototype, function (value, name) {
35 |     if (p[name] === undefined) {
36 |       p[name] = value;
37 |     }
38 |   });
39 | 
40 | 
41 |   /**
42 |    * Override a parent method.
43 |    *
44 |    * @see BasePrototypeFunctionality#setControllerName
45 |    */
46 |   p.setControllerName = function () {
47 |     this.$scope.controllerName = 'mixinWithPrototypicalInheritanceController';
48 |   };
49 | 
50 |   /**
51 |    * Override a parent method.
52 |    */
53 |   p.initialize = function () {
54 |     var self = this;
55 |     // Call the parent class function.
56 |     MixinWithPrototypicalInheritanceController.super_.prototype.initialize.apply(this, arguments);
57 |     // Then decorate the scope with this detector function for the mixin
58 |     // prototype methods.
59 |     this.$scope.mixinPrototypeFunctionsInherited = function () {
60 |       return (typeof self.mixinPrototypeFunction === 'function');
61 |     };
62 |   };
63 | 
64 |   /**
65 |    * Detector for whether or not prototype functions from the mixing turned up.
66 |    *
67 |    * @return {boolean}
68 |    *   Return true if the prototype is decorated with mixin controller
69 |    *   methods.
70 |    */
71 |   p.mixinPrototypeFunctionsInherited = function () {
72 |     return (typeof this.mixinPrototypeFunction === 'function');
73 |   };
74 | 
75 |   inheritance.MixinWithPrototypicalInheritanceControllerConstructor = MixinWithPrototypicalInheritanceController;
76 |   inheritance.controller('mixinWithPrototypicalInheritanceController', [
77 |     '$scope',
78 |     MixinWithPrototypicalInheritanceController
79 |   ]);
80 | 
81 | })();
82 | 


--------------------------------------------------------------------------------
/client/partial/generic.html:
--------------------------------------------------------------------------------
 1 | <p>
 2 |   Controller for this page: <span>{{controllerName}}</span>
 3 | </p>
 4 | <p data-ng-show="mixinControllerNames.length">
 5 |   Mixins: <span data-ng-repeat="name in mixinControllerNames">{{name}} </span>
 6 | </p>
 7 | <p data-ng-show="mixinControllerNames.length">
 8 |   Controller inherited mixin prototype functions: <span>{{mixinPrototypeFunctionsInherited()}}</span>
 9 | </p>
10 | 


--------------------------------------------------------------------------------
/client/partial/home.html:
--------------------------------------------------------------------------------
 1 | <p>
 2 | This is the boring front end. It shows little and only exists to put the
 3 | controllers into context. You should read the project README document and
 4 | controller code to see what is going on.
 5 | </p>
 6 | 
 7 | <ul>
 8 |   <li>
 9 |     <a href="#/inheritByInjector">
10 |       Page controller inherits from a base controller via $injector
11 |     </a>
12 |   </li>
13 |   <li>
14 |     <a href="#/mixinByInjector">
15 |       Mixin: page controller inherits from multiple controllers via $injector
16 |     </a>
17 |   </li>
18 |   <li>
19 |     <a href="#/inheritPrototypically">
20 |       Page controller inherits from a base controller prototypically
21 |     </a>
22 |   </li>
23 |   <li>
24 |     <a href="#/mixinWithPrototypicalInheritance">
25 |       Mixin: page controller inherits prototypically with an added mixin inheritance.
26 |     </a>
27 |   </li>
28 | </ul>
29 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('./server/express');
2 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name" : "angularjs-controller-inheritance",
 3 |   "description": "Examples of controller inheritance in AngularJS.",
 4 |   "keywords": ["angularjs", "controller", "inheritance"],
 5 |   "version": "0.0.1",
 6 |   "homepage": "https://github.com/exratione/angularjs-controller-inheritance",
 7 |   "author": "Reason <reason@exratione.com>",
 8 |   "engines": {
 9 |     "node": ">= 0.10"
10 |   },
11 |   "dependencies": {
12 |     "express": "3.x.x"
13 |   },
14 |   "main" : "./index",
15 |   "repository" : {
16 |     "type" : "git",
17 |     "url" : "https://github.com/exratione/angularjs-controller-inheritance"
18 |   },
19 |   "licenses" : [{
20 |     "type" : "MIT",
21 |     "url" : "https://github.com/exratione/angularjs-controller-inheritance/raw/master/LICENSE"
22 |   }]
23 | }
24 | 


--------------------------------------------------------------------------------
/server/express.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileOverview
 3 |  * Launch an Express server for the AngularJS application.
 4 |  */
 5 | 
 6 | var http = require('http');
 7 | var path = require('path');
 8 | var express = require('express');
 9 | 
10 | var app = express();
11 | // Static file serving from ../client.
12 | app.use(express.static(path.join(__dirname, '../client')));
13 | 
14 | // Launch the server.
15 | var server = http.createServer(app).listen(10080);
16 | 


--------------------------------------------------------------------------------