/**

* The MIT License

*

* Copyright (c) 2010 Adam Abrons and Misko Hevery http://getangular.com

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*/

(function(window, document, previousOnLoad){

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

if (typeof document.getAttribute == $undefined)

document.getAttribute = function() {};

var _undefined = undefined,

_null = null,

$$element = '$element',

$angular = 'angular',

$array = 'array',

$boolean = 'boolean',

$console = 'console',

$date = 'date',

$display = 'display',

$element = 'element',

$function = 'function',

$length = 'length',

$name = 'name',

$none = 'none',

$noop = 'noop',

$null = 'null',

$number = 'number',

$object = 'object',

$string = 'string',

$undefined = 'undefined',

NG_EXCEPTION = 'ng-exception',

NG_VALIDATION_ERROR = 'ng-validation-error',

NOOP = 'noop',

PRIORITY_FIRST = -99999,

PRIORITY_WATCH = -1000,

PRIORITY_LAST = 99999,

PRIORITY = {'FIRST': PRIORITY_FIRST, 'LAST': PRIORITY_LAST, 'WATCH':PRIORITY_WATCH},

jQuery = window['jQuery'] || window['$'], // weirdness to make IE happy

_ = window['_'],

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

msie = parseInt((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1], 10),

jqLite = jQuery || jqLiteWrap,

slice = Array.prototype.slice,

push = Array.prototype.push,

error = window[$console] ? bind(window[$console], window[$console]['error'] || noop) : noop,

angular = window[$angular] || (window[$angular] = {}),

angularTextMarkup = extensionMap(angular, 'markup'),

angularAttrMarkup = extensionMap(angular, 'attrMarkup'),

angularDirective = extensionMap(angular, 'directive'),

angularWidget = extensionMap(angular, 'widget', lowercase),

angularValidator = extensionMap(angular, 'validator'),

angularFilter = extensionMap(angular, 'filter'),

angularFormatter = extensionMap(angular, 'formatter'),

angularService = extensionMap(angular, 'service'),

angularCallbacks = extensionMap(angular, 'callbacks'),

nodeName,

rngScript = /^(|.*\/)angular(-.*?)?(\.min)?.js(\?[^#]*)?(#(.*))?$/;

function foreach(obj, iterator, context) {

var key;

if (obj) {

if (isFunction(obj)){

for (key in obj) {

if (key != 'prototype' && key != $length && key != $name && obj.hasOwnProperty(key)) {

iterator.call(context, obj[key], key);

}

}

} else if (obj.forEach) {

obj.forEach(iterator, context);

} else if (isObject(obj) && isNumber(obj.length)) {

for (key = 0; key < obj.length; key++)

iterator.call(context, obj[key], key);

} else {

for (key in obj)

iterator.call(context, obj[key], key);

}

}

return obj;

}

function foreachSorted(obj, iterator, context) {

var keys = [];

for (var key in obj) keys.push(key);

keys.sort();

for ( var i = 0; i < keys.length; i++) {

iterator.call(context, obj[keys[i]], keys[i]);

}

return keys;

}

function extend(dst) {

foreach(arguments, function(obj){

if (obj !== dst) {

foreach(obj, function(value, key){

dst[key] = value;

});

}

});

return dst;

}

function inherit(parent, extra) {

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

}

function noop() {}

function identity($) {return $;}

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

function extensionMap(angular, name, transform) {

var extPoint;

return angular[name] || (extPoint = angular[name] = function (name, fn, prop){

name = (transform || identity)(name);

if (isDefined(fn)) {

extPoint[name] = extend(fn, prop || {});

}

return extPoint[name];

});

}

function jqLiteWrap(element) {

// for some reasons the parentNode of an orphan looks like _null but its typeof is object.

if (element) {

if (isString(element)) {

var div = document.createElement('div');

div.innerHTML = element;

element = new JQLite(div.childNodes);

} else if (!(element instanceof JQLite) && isElement(element)) {

element = new JQLite(element);

}

}

return element;

}

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

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

function isObject(value){ return value!=_null && typeof value == $object;}

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

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

function isArray(value) { return value instanceof Array; }

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

function isTextNode(node) { return nodeName(node) == '#text'; }

function lowercase(value){ return isString(value) ? value.toLowerCase() : value; }

function uppercase(value){ return isString(value) ? value.toUpperCase() : value; }

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

function isElement(node) {

return node && (node.nodeName || node instanceof JQLite || (jQuery && node instanceof jQuery));

}

function HTML(html) {

this.html = html;

}

if (msie) {

nodeName = function(element) {

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

return (element.scopeName && element.scopeName != 'HTML' ) ? uppercase(element.scopeName + ':' + element.nodeName) : element.nodeName;

};

} else {

nodeName = function(element) {

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

};

}

function quickClone(element) {

return jqLite(element[0].cloneNode(true));

}

function isVisible(element) {

var rect = element[0].getBoundingClientRect(),

width = (rect.width || (rect.right||0 - rect.left||0)),

height = (rect.height || (rect.bottom||0 - rect.top||0));

return width>0 && height>0;

}

function map(obj, iterator, context) {

var results = [];

foreach(obj, function(value, index, list) {

results.push(iterator.call(context, value, index, list));

});

return results;

}

function size(obj) {

var size = 0;

if (obj) {

if (isNumber(obj.length)) {

return obj.length;

} else if (isObject(obj)){

for (key in obj)

size++;

}

}

return size;

}

function includes(array, obj) {

for ( var i = 0; i < array.length; i++) {

if (obj === array[i]) return true;

}

return false;

}

function indexOf(array, obj) {

for ( var i = 0; i < array.length; i++) {

if (obj === array[i]) return i;

}

return -1;

}

function isLeafNode (node) {

if (node) {

switch (node.nodeName) {

case "OPTION":

case "PRE":

case "TITLE":

return true;

}

}

return false;

}

/**

* Copies stuff.

*

* If destination is not provided and source is an object or an array, a copy is created & returned,

* otherwise the source is returned.

*

* If destination is provided, all of its properties will be deleted and if source is an object or

* an array, all of its members will be copied into the destination object. Finally the destination

* is returned just for kicks.

*

* @param {*} source The source to be used during copy.

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

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

* @return {*}

*/

function copy(source, destination){

if (!destination) {

destination = source;

if (source) {

if (isArray(source)) {

destination = copy(source, []);

} else if (source instanceof Date) {

destination = new Date(source.getTime());

} else if (isObject(source)) {

destination = copy(source, {});

}

}

} else {

if (isArray(source)) {

while(destination.length) {

destination.pop();

}

for ( var i = 0; i < source.length; i++) {

destination.push(copy(source[i]));

}

} else {

foreach(destination, function(value, key){

delete destination[key];

});

for ( var key in source) {

destination[key] = copy(source[key]);

}

}

}

return destination;

}

function equals(o1, o2) {

if (o1 == o2) return true;

var t1 = typeof o1, t2 = typeof o2, length, key, keySet;

if (t1 == t2 && t1 == 'object') {

if (o1 instanceof Array) {

if ((length = o1.length) == o2.length) {

for(key=0; key<length; key++) {

if (!equals(o1[key], o2[key])) return false;

}

return true;

}

} else {

keySet = {};

for(key in o1) {

if (key.charAt(0) !== '$' && !isFunction(o1[key]) && !equals(o1[key], o2[key])) return false;

keySet[key] = true;

}

for(key in o2) {

if (!keySet[key] && key.charAt(0) !== '$' && !isFunction(o2[key])) return false;

}

return true;

}

}

return false;

}

function setHtml(node, html) {

if (isLeafNode(node)) {

if (msie) {

node.innerText = html;

} else {

node.textContent = html;

}

} else {

node.innerHTML = html;

}

}

function escapeHtml(html) {

if (!html || !html.replace)

return html;

return html.

replace(/&/g, '&amp;').

replace(/</g, '&lt;').

replace(/>/g, '&gt;');

}

function isRenderableElement(element) {

var name = element && element[0] && element[0].nodeName;

return name && name.charAt(0) != '#' &&

!includes(['TR', 'COL', 'COLGROUP', 'TBODY', 'THEAD', 'TFOOT'], name);

}

function elementError(element, type, error) {

while (!isRenderableElement(element)) {

element = element.parent() || jqLite(document.body);

}

if (element[0]['$NG_ERROR'] !== error) {

element[0]['$NG_ERROR'] = error;

if (error) {

element.addClass(type);

element.attr(type, error);

} else {

element.removeClass(type);

element.removeAttr(type);

}

}

}

function escapeAttr(html) {

if (!html || !html.replace)

return html;

return html.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\"/g,

'&quot;');

}

function concat(array1, array2, index) {

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

}

function bind(self, fn) {

var curryArgs = arguments.length > 2 ? slice.call(arguments, 2, arguments.length) : [];

if (typeof fn == $function) {

return curryArgs.length ? function() {

return arguments.length ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0, arguments.length))) : fn.apply(self, curryArgs);

}: function() {

return arguments.length ? fn.apply(self, arguments) : fn.call(self);

};

} else {

// in IE, native methods ore not functions and so they can not be bound (but they don't need to be)

return fn;

}

}

function toBoolean(value) {

if (value && value.length !== 0) {

var v = lowercase("" + value);

value = !(v == 'f' || v == '0' || v == 'false' || v == 'no' || v == 'n' || v == '[]');

} else {

value = false;

}

return value;

}

function merge(src, dst) {

for ( var key in src) {

var value = dst[key];

var type = typeof value;

if (type == $undefined) {

dst[key] = fromJson(toJson(src[key]));

} else if (type == 'object' && value.constructor != array &&

key.substring(0, 1) != "$") {

merge(src[key], value);

}

}

}

function compile(element, existingScope) {

var compiler = new Compiler(angularTextMarkup, angularAttrMarkup, angularDirective, angularWidget),

$element = jqLite(element);

return compiler.compile($element)($element, existingScope);

}

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

/**

* Parses an escaped url query string into key-value pairs.

* @return Object.<(string|boolean)>

*/

function parseKeyValue(/**string*/keyValue) {

var obj = {}, key_value, key;

foreach((keyValue || "").split('&'), function(keyValue){

if (keyValue) {

key_value = keyValue.split('=');

key = unescape(key_value[0]);

obj[key] = isDefined(key_value[1]) ? unescape(key_value[1]) : true;

}

});

return obj;

}

function toKeyValue(obj) {

var parts = [];

foreach(obj, function(value, key) {

parts.push(escape(key) + (value === true ? '' : '=' + escape(value)));

});

return parts.length ? parts.join('&') : '';

}

function angularInit(config){

if (config.autobind) {

// TODO default to the source of angular.js

var scope = compile(window.document, _null, {'$config':config}),

$browser = scope.$inject('$browser');

if (config.css)

$browser.addCss(config.base_url + config.css);

else if(msie<8)

$browser.addJs(config.base_url + config.ie_compat, config.ie_compat_id);

scope.$init();

}

}

function angularJsConfig(document, config) {

var scripts = document.getElementsByTagName("script"),

match;

config = extend({

ie_compat_id: 'ng-ie-compat'

}, config);

for(var j = 0; j < scripts.length; j++) {

match = (scripts[j].src || "").match(rngScript);

if (match) {

config.base_url = match[1];

config.ie_compat = match[1] + 'angular-ie-compat' + (match[2] || '') + '.js';

extend(config, parseKeyValue(match[6]));

eachAttribute(jqLite(scripts[j]), function(value, name){

if (/^ng:/.exec(name)) {

name = name.substring(3).replace(/-/g, '_');

if (name == 'autobind') value = true;

config[name] = value;

}

});

}

}

return config;

}

var array = [].constructor;

function toJson(obj, pretty){

var buf = [];

toJsonArray(buf, obj, pretty ? "\n " : _null, []);

return buf.join('');

}

function fromJson(json) {

if (!json) return json;

try {

var p = parser(json, true);

var expression = p.primary();

p.assertAllConsumed();

return expression();

} catch (e) {

error("fromJson error: ", json, e);

throw e;

}

}

angular['toJson'] = toJson;

angular['fromJson'] = fromJson;

function toJsonArray(buf, obj, pretty, stack){

if (typeof obj == "object") {

if (includes(stack, obj)) {

buf.push("RECURSION");

return;

}

stack.push(obj);

}

var type = typeof obj;

if (obj === _null) {

buf.push($null);

} else if (type === $function) {

return;

} else if (type === $boolean) {

buf.push('' + obj);

} else if (type === $number) {

if (isNaN(obj)) {

buf.push($null);

} else {

buf.push('' + obj);

}

} else if (type === $string) {

return buf.push(angular['String']['quoteUnicode'](obj));

} else if (type === $object) {

if (obj instanceof Array) {

buf.push("[");

var len = obj.length;

var sep = false;

for(var i=0; i<len; i++) {

var item = obj[i];

if (sep) buf.push(",");

if (typeof item == $function || typeof item == $undefined) {

buf.push($null);

} else {

toJsonArray(buf, item, pretty, stack);

}

sep = true;

}

buf.push("]");

} else if (obj instanceof Date) {

buf.push(angular['String']['quoteUnicode'](angular['Date']['toString'](obj)));

} else {

buf.push("{");

if (pretty) buf.push(pretty);

var comma = false;

var childPretty = pretty ? pretty + " " : false;

var keys = [];

for(var k in obj) {

if (k.indexOf('$') === 0 || obj[k] === _undefined)

continue;

keys.push(k);

}

keys.sort();

for ( var keyIndex = 0; keyIndex < keys.length; keyIndex++) {

var key = keys[keyIndex];

var value = obj[key];

if (typeof value != $function) {

if (comma) {

buf.push(",");

if (pretty) buf.push(pretty);

}

buf.push(angular['String']['quote'](key));

buf.push(":");

toJsonArray(buf, value, childPretty, stack);

comma = true;

}

}

buf.push("}");

}

}

if (typeof obj == $object) {

stack.pop();

}

}

/**

* Template provides directions an how to bind to a given element.

* It contains a list of init functions which need to be called to

* bind to a new instance of elements. It also provides a list

* of child paths which contain child templates

*/

function Template(priority) {

this.paths = [];

this.children = [];

this.inits = [];

this.priority = priority;

this.newScope = false;

}

Template.prototype = {

init: function(element, scope) {

var inits = {};

this.collectInits(element, inits, scope);

foreachSorted(inits, function(queue){

foreach(queue, function(fn) {fn();});

});

},

collectInits: function(element, inits, scope) {

var queue = inits[this.priority], childScope = scope;

if (!queue) {

inits[this.priority] = queue = [];

}

element = jqLite(element);

if (this.newScope) {

childScope = createScope(scope);

scope.$onEval(childScope.$eval);

}

foreach(this.inits, function(fn) {

queue.push(function() {

childScope.$tryEval(function(){

return childScope.$inject(fn, childScope, element);

}, element);

});

});

var i,

childNodes = element[0].childNodes,

children = this.children,

paths = this.paths,

length = paths.length;

for (i = 0; i < length; i++) {

children[i].collectInits(childNodes[paths[i]], inits, childScope);

}

},

addInit:function(init) {

if (init) {

this.inits.push(init);

}

},

addChild: function(index, template) {

if (template) {

this.paths.push(index);

this.children.push(template);

}

},

empty: function() {

return this.inits.length === 0 && this.paths.length === 0;

}

};

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

//Compiler

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

function Compiler(markup, attrMarkup, directives, widgets){

this.markup = markup;

this.attrMarkup = attrMarkup;

this.directives = directives;

this.widgets = widgets;

}

Compiler.prototype = {

compile: function(rawElement) {

rawElement = jqLite(rawElement);

var index = 0,

template,

parent = rawElement.parent();

if (parent && parent[0]) {

parent = parent[0];

for(var i = 0; i < parent.childNodes.length; i++) {

if (parent.childNodes[i] == rawElement[0]) {

index = i;

}

}

}

template = this.templatize(rawElement, index, 0) || new Template();

return function(element, parentScope){

element = jqLite(element);

var scope = parentScope && parentScope.$eval ?

parentScope : createScope(parentScope);

return extend(scope, {

$element:element,

$init: function() {

template.init(element, scope);

scope.$eval();

delete scope.$init;

return scope;

}

});

};

},

templatize: function(element, elementIndex, priority){

var self = this,

widget,

directiveFns = self.directives,

descend = true,

directives = true,

template,

selfApi = {

compile: bind(self, self.compile),

comment:function(text) {return jqLite(document.createComment(text));},

element:function(type) {return jqLite(document.createElement(type));},

text:function(text) {return jqLite(document.createTextNode(text));},

descend: function(value){ if(isDefined(value)) descend = value; return descend;},

directives: function(value){ if(isDefined(value)) directives = value; return directives;},

scope: function(value){ if(isDefined(value)) template.newScope = template.newScope || value; return template.newScope;}

};

try {

priority = element.attr('ng:eval-order') || priority || 0;

} catch (e) {

// for some reason IE throws error under some weird circumstances. so just assume nothing

priority = priority || 0;

}

if (isString(priority)) {

priority = PRIORITY[uppercase(priority)] || parseInt(priority, 10);

}

template = new Template(priority);

eachAttribute(element, function(value, name){

if (!widget) {

if (widget = self.widgets('@' + name)) {

widget = bind(selfApi, widget, value, element);

}

}

});

if (!widget) {

if (widget = self.widgets(nodeName(element))) {

widget = bind(selfApi, widget, element);

}

}

if (widget) {

descend = false;

directives = false;

var parent = element.parent();

template.addInit(widget.call(selfApi, element));

if (parent && parent[0]) {

element = jqLite(parent[0].childNodes[elementIndex]);

}

}

if (descend){

// process markup for text nodes only

for(var i=0, child=element[0].childNodes;

i<child.length; i++) {

if (isTextNode(child[i])) {

foreach(self.markup, function(markup){

if (i<child.length) {

var textNode = jqLite(child[i]);

markup.call(selfApi, textNode.text(), textNode, element);

}

});

}

}

}

if (directives) {

// Process attributes/directives

eachAttribute(element, function(value, name){

foreach(self.attrMarkup, function(markup){

markup.call(selfApi, value, name, element);

});

});

eachAttribute(element, function(value, name){

template.addInit((directiveFns[name]||noop).call(selfApi, value, element));

});

}

// Process non text child nodes

if (descend) {

eachNode(element, function(child, i){

template.addChild(i, self.templatize(child, i, priority));

});

}

return template.empty() ? _null : template;

}

};

function eachNode(element, fn){

var i, chldNodes = element[0].childNodes || [], chld;

for (i = 0; i < chldNodes.length; i++) {

if(!isTextNode(chld = chldNodes[i])) {

fn(jqLite(chld), i);

}

}

}

function eachAttribute(element, fn){

var i, attrs = element[0].attributes || [], chld, attr, name, value, attrValue = {};

for (i = 0; i < attrs.length; i++) {

attr = attrs[i];

name = attr.name;

value = attr.value;

if (msie && name == 'href') {

value = decodeURIComponent(element[0].getAttribute(name, 2));

}

attrValue[name] = value;

}

foreachSorted(attrValue, fn);

}

function getter(instance, path, unboundFn) {

if (!path) return instance;

var element = path.split('.');

var key;

var lastInstance = instance;

var len = element.length;

for ( var i = 0; i < len; i++) {

key = element[i];

if (!key.match(/^[\$\w][\$\w\d]*$/))

throw "Expression '" + path + "' is not a valid expression for accesing variables.";

if (instance) {

lastInstance = instance;

instance = instance[key];

}

if (isUndefined(instance) && key.charAt(0) == '$') {

var type = angular['Global']['typeOf'](lastInstance);

type = angular[type.charAt(0).toUpperCase()+type.substring(1)];

var fn = type ? type[[key.substring(1)]] : _undefined;

if (fn) {

instance = bind(lastInstance, fn, lastInstance);

return instance;

}

}

}

if (!unboundFn && isFunction(instance)) {

return bind(lastInstance, instance);

}

return instance;

}

function setter(instance, path, value){

var element = path.split('.');

for ( var i = 0; element.length > 1; i++) {

var key = element.shift();

var newInstance = instance[key];

if (!newInstance) {

newInstance = {};

instance[key] = newInstance;

}

instance = newInstance;

}

instance[element.shift()] = value;

return value;

}

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

var scopeId = 0,

getterFnCache = {},

compileCache = {},

JS_KEYWORDS = {};

foreach(

["abstract", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default",

"delete", "do", "double", "else", "enum", "export", "extends", "false", "final", "finally", "float", "for", $function, "goto",

"if", "implements", "import", "ininstanceof", "intinterface", "long", "native", "new", $null, "package", "private",

"protected", "public", "return", "short", "static", "super", "switch", "synchronized", "this", "throw", "throws",

"transient", "true", "try", "typeof", "var", "volatile", "void", $undefined, "while", "with"],

function(key){ JS_KEYWORDS[key] = true;}

);

function getterFn(path){

var fn = getterFnCache[path];

if (fn) return fn;

var code = 'var l, fn, t;\n';

foreach(path.split('.'), function(key) {

key = (JS_KEYWORDS[key]) ? '["' + key + '"]' : '.' + key;

code += 'if(!s) return s;\n' +

'l=s;\n' +

's=s' + key + ';\n' +

'if(typeof s=="function") s = function(){ return l'+key+'.apply(l, arguments); };\n';

if (key.charAt(1) == '$') {

// special code for super-imposed functions

var name = key.substr(2);

code += 'if(!s) {\n' +

' t = angular.Global.typeOf(l);\n' +

' fn = (angular[t.charAt(0).toUpperCase() + t.substring(1)]||{})["' + name + '"];\n' +

' if (fn) s = function(){ return fn.apply(l, [l].concat(Array.prototype.slice.call(arguments, 0, arguments.length))); };\n' +

'}\n';

}

});

code += 'return s;';

fn = Function('s', code);

fn["toString"] = function(){ return code; };

return getterFnCache[path] = fn;

}

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

function expressionCompile(exp){

if (typeof exp === $function) return exp;

var fn = compileCache[exp];

if (!fn) {

var p = parser(exp);

var fnSelf = p.statements();

p.assertAllConsumed();

fn = compileCache[exp] = extend(

function(){ return fnSelf(this);},

{fnSelf: fnSelf});

}

return fn;

}

function errorHandlerFor(element, error) {

elementError(element, NG_EXCEPTION, isDefined(error) ? toJson(error) : error);

}

function createScope(parent, providers, instanceCache) {

function Parent(){}

parent = Parent.prototype = (parent || {});

var instance = new Parent();

var evalLists = {sorted:[]};

var postList = [], postHash = {}, postId = 0;

extend(instance, {

'this': instance,

$id: (scopeId++),

$parent: parent,

$bind: bind(instance, bind, instance),

$get: bind(instance, getter, instance),

$set: bind(instance, setter, instance),

$eval: function $eval(exp) {

var type = typeof exp;

var i, iSize;

var j, jSize;

var queue;

var fn;

if (type == $undefined) {

for ( i = 0, iSize = evalLists.sorted.length; i < iSize; i++) {

for ( queue = evalLists.sorted[i],

jSize = queue.length,

j= 0; j < jSize; j++) {

instance.$tryEval(queue[j].fn, queue[j].handler);

}

}

while(postList.length) {

fn = postList.shift();

delete postHash[fn.$postEvalId];

instance.$tryEval(fn);

}

} else if (type === $function) {

return exp.call(instance);

} else if (type === 'string') {

return expressionCompile(exp).call(instance);

}

},

$tryEval: function (expression, exceptionHandler) {

var type = typeof expression;

try {

if (type == $function) {

return expression.call(instance);

} else if (type == 'string'){

return expressionCompile(expression).call(instance);

}

} catch (e) {

(instance.$log || {error:error}).error(e);

if (isFunction(exceptionHandler)) {

exceptionHandler(e);

} else if (exceptionHandler) {

errorHandlerFor(exceptionHandler, e);

} else if (isFunction(instance.$exceptionHandler)) {

instance.$exceptionHandler(e);

}

}

},

$watch: function(watchExp, listener, exceptionHandler) {

var watch = expressionCompile(watchExp),

last;

listener = expressionCompile(listener);

function watcher(){

var value = watch.call(instance),

lastValue = last;

if (last !== value) {

last = value;

instance.$tryEval(function(){

return listener.call(instance, value, lastValue);

}, exceptionHandler);

}

}

instance.$onEval(PRIORITY_WATCH, watcher);

watcher();

},

$onEval: function(priority, expr, exceptionHandler){

if (!isNumber(priority)) {

exceptionHandler = expr;

expr = priority;

priority = 0;

}

var evalList = evalLists[priority];

if (!evalList) {

evalList = evalLists[priority] = [];

evalList.priority = priority;

evalLists.sorted.push(evalList);

evalLists.sorted.sort(function(a,b){return a.priority-b.priority;});

}

evalList.push({

fn: expressionCompile(expr),

handler: exceptionHandler

});

},

$postEval: function(expr) {

if (expr) {

var fn = expressionCompile(expr);

var id = fn.$postEvalId;

if (!id) {

id = '$' + instance.$id + "_" + (postId++);

fn.$postEvalId = id;

}

if (!postHash[id]) {

postList.push(postHash[id] = fn);