You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@shindig.apache.org by br...@apache.org on 2007/12/22 17:11:58 UTC
svn commit: r606463 [2/5] - in /incubator/shindig/trunk/php: ./ js/
Added: incubator/shindig/trunk/php/js/People.js
URL: http://svn.apache.org/viewvc/incubator/shindig/trunk/php/js/People.js?rev=606463&view=auto
==============================================================================
--- incubator/shindig/trunk/php/js/People.js (added)
+++ incubator/shindig/trunk/php/js/People.js Sat Dec 22 08:11:57 2007
@@ -0,0 +1,5670 @@
+var goog = goog || {};
+goog.global = this;
+goog.evalWorksForGlobals_ = null;
+goog.provide = function(name) {
+ goog.exportPath_(name)
+};
+goog.exportPath_ = function(name, opt_object) {
+ var parts = name.split("."), cur = goog.global, part;
+ while(part = parts.shift()) {
+ if(!parts.length && goog.isDef(opt_object)) {
+ cur[part] = opt_object
+ }else if(cur[part]) {
+ cur = cur[part]
+ }else {
+ cur = (cur[part] = {})
+ }
+ }
+};
+goog.getObjectByName = function(name) {
+ var parts = name.split("."), cur = goog.global;
+ for(var part;part = parts.shift();) {
+ if(cur[part]) {
+ cur = cur[part]
+ }else {
+ return null
+ }
+ }return cur
+};
+goog.globalize = function(obj, opt_global) {
+ var global = opt_global || goog.global;
+ for(var x in obj) {
+ global[x] = obj[x]
+ }
+};
+goog.addDependency = function(relPath, provides, requires) {
+};
+goog.require = function(rule) {
+};
+goog.basePath = "";
+goog.nullFunction = function() {
+};
+goog.JsType_ = {UNDEFINED:"undefined", NUMBER:"number", STRING:"string", BOOLEAN:"boolean", FUNCTION:"function", OBJECT:"object"};
+goog.isDef = function(val) {
+ return typeof val != goog.JsType_.UNDEFINED
+};
+goog.isNull = function(val) {
+ return val === null
+};
+goog.isDefAndNotNull = function(val) {
+ return goog.isDef(val) && !goog.isNull(val)
+};
+goog.isArray = function(val) {
+ return val instanceof Array || goog.isObject(val) && typeof val.join == goog.JsType_.FUNCTION && typeof val.reverse == goog.JsType_.FUNCTION
+};
+goog.isArrayLike = function(val) {
+ return goog.isObject(val) && typeof val.length == goog.JsType_.NUMBER
+};
+goog.isDateLike = function(val) {
+ return goog.isObject(val) && goog.isFunction(val.getFullYear)
+};
+goog.isString = function(val) {
+ return typeof val == goog.JsType_.STRING
+};
+goog.isBoolean = function(val) {
+ return typeof val == goog.JsType_.BOOLEAN
+};
+goog.isNumber = function(val) {
+ return typeof val == goog.JsType_.NUMBER
+};
+goog.isFunction = function(val) {
+ return typeof val == goog.JsType_.FUNCTION || !(!(val && val.call))
+};
+goog.isObject = function(val) {
+ return val != null && typeof val == goog.JsType_.OBJECT
+};
+goog.getHashCode = function(obj) {
+ if(obj.hasOwnProperty && obj.hasOwnProperty(goog.HASH_CODE_PROPERTY_)) {
+ return obj[goog.HASH_CODE_PROPERTY_]
+ }if(!obj[goog.HASH_CODE_PROPERTY_]) {
+ obj[goog.HASH_CODE_PROPERTY_] = ++goog.hashCodeCounter_
+ }return obj[goog.HASH_CODE_PROPERTY_]
+};
+goog.removeHashCode = function(obj) {
+ if("removeAttribute" in obj) {
+ obj.removeAttribute(goog.HASH_CODE_PROPERTY_)
+ }try {
+ delete obj[goog.HASH_CODE_PROPERTY_]
+ }catch(ex) {
+ }
+};
+goog.HASH_CODE_PROPERTY_ = "closure_hashCode_";
+goog.hashCodeCounter_ = 0;
+goog.cloneObject = function(proto) {
+ if(goog.isObject(proto)) {
+ if(proto.clone) {
+ return proto.clone()
+ }var clone = goog.isArray(proto) ? [] : {};
+ for(var key in proto) {
+ clone[key] = goog.cloneObject(proto[key])
+ }return clone
+ }return proto
+};
+goog.bind = function(fn, self) {
+ var boundArgs = fn.boundArgs_;
+ if(arguments.length > 2) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ if(boundArgs) {
+ args.unshift.apply(args, boundArgs)
+ }boundArgs = args
+ }self = fn.boundSelf_ || self;
+ fn = fn.boundFn_ || fn;
+ var newfn, context = self || goog.global;
+ if(boundArgs) {
+ newfn = function() {
+ var args = Array.prototype.slice.call(arguments);
+ args.unshift.apply(args, boundArgs);
+ return fn.apply(context, args)
+ }
+ }else {
+ newfn = function() {
+ return fn.apply(context, arguments)
+ }
+ }newfn.boundArgs_ = boundArgs;
+ newfn.boundSelf_ = self;
+ newfn.boundFn_ = fn;
+ return newfn
+};
+goog.partial = function(fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ args.unshift(fn, null);
+ return goog.bind.apply(null, args)
+};
+goog.mixin = function(target, source) {
+ for(var x in source) {
+ target[x] = source[x]
+ }
+};
+goog.now = function() {
+ return(new Date).getTime()
+};
+goog.globalEval = function(script) {
+ if(goog.global.execScript) {
+ goog.global.execScript(script, "JavaScript")
+ }else if(goog.global.eval) {
+ if(goog.evalWorksForGlobals_ == null) {
+ goog.global.eval("var _et_ = 1;");
+ if(typeof goog.global._et_ != "undefined") {
+ delete goog.global._et_;
+ goog.evalWorksForGlobals_ = true
+ }else {
+ goog.evalWorksForGlobals_ = false
+ }
+ }if(goog.evalWorksForGlobals_) {
+ goog.global.eval(script)
+ }else {
+ var doc = goog.global.document, scriptElt = doc.createElement("script");
+ scriptElt.type = "text/javascript";
+ scriptElt.defer = false;
+ scriptElt.text = script;
+ doc.body.appendChild(scriptElt);
+ doc.body.removeChild(scriptElt)
+ }
+ }else {
+ throw Error("goog.globalEval not available");
+ }
+};
+goog.getMsg = function(str, opt_values) {
+ var values = opt_values || {};
+ for(var key in values) {
+ str = str.replace(new RegExp("\\{\\$" + key + "\\}", "gi"), values[key])
+ }return str
+};
+goog.exportSymbol = function(publicPath, object) {
+ goog.exportPath_(publicPath, object)
+};
+goog.exportProperty = function(object, publicName, symbol) {
+ object[publicName] = symbol
+};
+if(!Function.prototype.apply) {
+ Function.prototype.apply = function(oScope, args) {
+ var sarg = [], rtrn, call;
+ if(!oScope)oScope = goog.global;
+ if(!args)args = [];
+ for(var i = 0;i < args.length;i++) {
+ sarg[i] = "args[" + i + "]"
+ }call = "oScope.__applyTemp__.peek().(" + sarg.join(",") + ");";
+ if(!oScope.__applyTemp__) {
+ oScope.__applyTemp__ = []
+ }oScope.__applyTemp__.push(this);
+ rtrn = eval(call);
+ oScope.__applyTemp__.pop();
+ return rtrn
+ }
+}Function.prototype.bind = function(self) {
+ if(arguments.length > 1) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ args.unshift(this, self);
+ return goog.bind.apply(null, args)
+ }else {
+ return goog.bind(this, self)
+ }
+};
+Function.prototype.partial = function() {
+ var args = Array.prototype.slice.call(arguments);
+ args.unshift(this, null);
+ return goog.bind.apply(null, args)
+};
+Function.prototype.inherits = function(parentCtor) {
+ goog.inherits(this, parentCtor)
+};
+goog.inherits = function(childCtor, parentCtor) {
+ function tempCtor() {
+ }
+ tempCtor.prototype = parentCtor.prototype;
+ childCtor.superClass_ = parentCtor.prototype;
+ childCtor.prototype = new tempCtor;
+ childCtor.prototype.constructor = childCtor
+};
+Function.prototype.mixin = function(source) {
+ goog.mixin(this.prototype, source)
+};var s2 = {};
+s2.data = {};
+s2.data.Data = function() {
+};
+s2.data.Data.prototype.each = function(fn) {
+};
+s2.data.Data.prototype.eachProp = function(fn) {
+};
+s2.data.Data.prototype.getProp = function(name) {
+ this.eachProp(function(curName, value) {
+ if(curName == name) {
+ return value
+ }
+ });
+ return null
+};
+s2.data.Data.prototype.putProp = function(name, value) {
+};
+s2.data.Data.prototype.removeProp = function(name) {
+};
+s2.data.Data.prototype.propSize = function() {
+ var count = 0;
+ this.eachProp(function() {
+ count++
+ });
+ return count
+};
+s2.data.Data.prototype.removeAllProps = function() {
+ var props = [];
+ this.eachProp(function(name, value) {
+ props.push(name)
+ });
+ for(var i = 0;i < props.length;i++) {
+ this.removeProp(props[i])
+ }
+};
+s2.data.Data.prototype.getAt = function(key) {
+ this.each(function(value, curKey) {
+ if(curKey == key) {
+ return value
+ }
+ });
+ return null
+};
+s2.data.Data.prototype.putAt = function(key, value) {
+};
+s2.data.Data.prototype.removeAt = function(key) {
+};
+s2.data.Data.prototype.removeAll = function() {
+ var keys = [];
+ this.each(function(value, key) {
+ keys.push(key)
+ });
+ for(var i = keys.length - 1;i >= 0;i--) {
+ this.removeAt(keys[i])
+ }
+};
+s2.data.Data.prototype.size = function() {
+ var count = 0;
+ this.each(function() {
+ count++
+ });
+ return count
+};
+s2.data.Data.prototype.equals = function(other) {
+ return s2.data.equals(this, other, true)
+};
+s2.data.Data.prototype.isCollection = function() {
+ return false
+};
+s2.data.Data.prototype.find = function(matcher) {
+ if(goog.isFunction(matcher)) {
+ var result = [];
+ this.each(function(value) {
+ if(matcher(value)) {
+ result.push(value)
+ }
+ });
+ return new s2.data.ArrayWrapper(result)
+ }else {
+ var expr = new s2.data.Expr(matcher);
+ return expr.find(this)
+ }
+};
+s2.data.Data.prototype.findOne = function(matcher) {
+ if(goog.isFunction(matcher)) {
+ var found = null;
+ this.each(function(value) {
+ if(matcher(value) && !found) {
+ found = value
+ }
+ });
+ return found
+ }else {
+ var expr = new s2.data.Expr(matcher);
+ return expr.evaluate(this)
+ }
+};
+s2.data.Data.prototype.transform = function(transform) {
+ var results = [];
+ this.each(function(value, key) {
+ results.push(transform(value, key))
+ });
+ return s2.data.from(results)
+};
+s2.data.Data.prototype.sort = function(sort, opt_descending) {
+ var descending = !(!opt_descending), results = [];
+ this.each(function(value, key) {
+ results.push(value)
+ });
+ if(goog.isFunction(sort)) {
+ results.sort(sort, descending)
+ }else {
+ var expr = new s2.data.Expr(sort);
+ results.sort(function(lhs, rhs) {
+ var lhfield = expr.evaluate(lhs).getValue(), rhfield = expr.evaluate(rhs).getValue(), compare = s2.data.compare(lhfield, rhfield);
+ if(descending) {
+ return-1 * compare
+ }else {
+ return compare
+ }
+ })
+ }return s2.data.from(results)
+};
+s2.data.Data.prototype.evaluate = function(expr) {
+ var expr = new s2.data.Expr(expr);
+ return expr.evaluate(this)
+};
+s2.data.Data.prototype.getValue = function() {
+ return this
+};
+s2.data.Data.prototype.newInstance = function() {
+};
+s2.data.Data.prototype.clone = function() {
+ var clone = this.newInstance();
+ s2.data.cloneContents(this, clone);
+ return clone
+};
+s2.data.Data.prototype.getRoot = function() {
+ var parent = this.getParent();
+ if(parent) {
+ return parent.getRoot()
+ }else {
+ return s2.data.Root.getGlobal()
+ }
+};
+s2.data.Data.prototype.getParent = function() {
+ return null
+};
+s2.data.Data.prototype.setParent = function() {
+};
+s2.data.Data.prototype.isRef = function() {
+ return false
+};
+s2.data.from = function(obj, opt_parent, opt_wrapPrimitives) {
+ if(goog.isObject(obj)) {
+ if(obj.each || obj.eachProp) {
+ return obj
+ }else if(s2.data.Ref.canCreateReference(obj)) {
+ return s2.data.Ref.createRef(obj)
+ }else if(goog.isArray(obj)) {
+ return new s2.data.ArrayWrapper(obj)
+ }else {
+ return new s2.data.ObjectWrapper(obj)
+ }
+ }else {
+ if(opt_wrapPrimitives) {
+ if(obj == null) {
+ return s2.data.Null.getNull()
+ }else {
+ return new s2.data.Primitive(obj)
+ }
+ }else {
+ return obj
+ }
+ }
+};
+s2.data.fromParent = function(obj, parent, opt_wrapPrimitives) {
+ var obj = s2.data.from(obj, opt_wrapPrimitives);
+ if(obj && obj.setParent) {
+ obj.setParent(parent)
+ }return obj
+};
+s2.data.unwrapIfNeeded = function(obj) {
+ if(obj == null) {
+ return obj
+ }else if(obj[s2.data.DATA_PROP]) {
+ return obj[s2.data.DATA_PROP]
+ }else {
+ return obj
+ }
+};
+s2.data.Data.prototype.toDebugString = function() {
+ var out = "";
+ this.eachProp(function(name, value) {
+ out += name + ": " + value.toString() + "\n"
+ });
+ this.each(function(value, key) {
+ out += "[" + key + "]: " + value.toString() + "\n"
+ });
+ if(out == "") {
+ out = "<No Data>"
+ }return out
+};
+s2.data.equals = function(lhs, rhs, opt_noTestObjEquals) {
+ if(lhs === rhs) {
+ return true
+ }if(lhs == null && rhs != null) {
+ return false
+ }if(rhs == null && lhs != null) {
+ return false
+ }if(!opt_noTestObjEquals && lhs.equals) {
+ return lhs.equals(rhs)
+ }if(!opt_noTestObjEquals && rhs.equals) {
+ return rhs.equals(lhs)
+ }if(goog.isString(lhs) || goog.isNumber(lhs)) {
+ return lhs == rhs
+ }if(lhs.propSize() != rhs.propSize()) {
+ return false
+ }var mismatches = 0;
+ lhs.eachProp(function(name, value) {
+ if(!s2.data.equals(rhs.getProp(name), value)) {
+ mismatches++
+ }
+ });
+ if(mismatches > 0) {
+ return false
+ }if(lhs.size() != rhs.size()) {
+ return false
+ }mismatches = 0;
+ lhs.each(function(value, key) {
+ if(!s2.data.equals(rhs.getAt(key), value)) {
+ mismatches++
+ }
+ });
+ if(mismatches > 0) {
+ return false
+ }return true
+};
+s2.data.compare = function(lhs, rhs) {
+ if(lhs == null && rhs != null) {
+ return 1
+ }if(rhs == null && lhs != null) {
+ return-1
+ }if(rhs == lhs) {
+ return 0
+ }if(goog.isString(lhs)) {
+ lhs = lhs.toLowerCase()
+ }if(goog.isString(rhs)) {
+ rhs = rhs.toLowerCase()
+ }return rhs > lhs ? -1 : 1
+};
+s2.data.cloneContents = function(src, target) {
+ src.eachProp(function(name, value) {
+ if(value.clone) {
+ value = value.clone()
+ }target.putProp(name, value)
+ });
+ src.each(function(value, key) {
+ if(value.clone) {
+ value = value.clone()
+ }target.putAt(key, value)
+ })
+};
+s2.data.DATA_PROP = "__data__";
+s2.data.PARENT_PROP = "__parentdata__";s2.data.Expr = function(src) {
+ if(src.evaluate) {
+ return src
+ }if(goog.isFunction(src)) {
+ this.evaluator_ = src
+ }else if(goog.isString(src)) {
+ this.src_ = src;
+ this.getterStack_ = [];
+ if(src.indexOf("$") == 0) {
+ this.getterStack_.push({type:"getGlobal"});
+ src = src.substring(1)
+ }var parts = src.split(".");
+ for(var i = 0;i < parts.length;i++) {
+ var part = parts[i], indexes = part.split("[");
+ if(!goog.string.startsWith(part, "[")) {
+ this.getterStack_.push({type:"getProp", value:indexes[0]})
+ }for(var j = 1;j < indexes.length;j++) {
+ var index = indexes[j], indexEnd = index.indexOf("]"), indexValue = index.substring(0, indexEnd), firstChar = index.substring(0, 1);
+ if(firstChar == "*") {
+ this.getterStack_.push({type:"getAllChildren"})
+ }else if(firstChar == "'" || firstChar == '"') {
+ this.getterStack_.push({type:"getAt", value:indexValue.substring(1, indexValue.length - 1)})
+ }else {
+ this.getterStack_.push({type:"getAt", value:Number(indexValue)})
+ }
+ }
+ }var getterStack = this.getterStack_;
+ this.evaluator_ = function(context) {
+ var cur = context;
+ for(var i = 0;i < getterStack.length;i++) {
+ var type = getterStack[i].type, value = getterStack[i].value;
+ if(type == "getGlobal") {
+ if(!cur) {
+ cur = s2.data.Root.getGlobal()
+ }else {
+ cur = cur.getRoot()
+ }
+ }if(type == "getProp") {
+ cur = cur.getProp(value)
+ }else if(type == "getAt") {
+ cur = cur.getAt(value)
+ }else if(type == "getAllChildren") {
+ cur = cur.find(function() {
+ return true
+ })
+ }
+ }return cur
+ }
+ }
+};
+s2.data.Expr.prototype.evaluate = function(opt_context) {
+ var context = opt_context || s2.data.Root.getGlobal(), result = this.evaluator_(new s2.data.ChainingProxy(context));
+ if(result.getProxiedObject) {
+ result = result.getProxiedObject()
+ }return result
+};
+s2.data.Expr.prototype.find = function(opt_context) {
+ var context = opt_context || s2.data.Root.getGlobal(), result = this.evaluator_(new s2.data.ChainingProxy(context));
+ if(!result.isCollection()) {
+ if(result.getValue && result.getValue() == null) {
+ result = s2.data.from([])
+ }else {
+ result = s2.data.from([result])
+ }
+ }return result
+};s2.data.Null = function() {
+ s2.data.Data.call(this)
+};
+s2.data.Null.inherits(s2.data.Data);
+s2.data.Null.prototype.getAt = function(key) {
+ return s2.data.Null.getNull()
+};
+s2.data.Null.prototype.getProp = function(name) {
+ return s2.data.Null.getNull()
+};
+s2.data.Null.prototype.getValue = function() {
+ return null
+};
+s2.data.Null.prototype.equals = function(other) {
+ return other == null || other.getValue && other.getValue() == null
+};
+s2.data.Null.theOnlyNullData_ = new s2.data.Null;
+s2.data.Null.getNull = function() {
+ return s2.data.Null.theOnlyNullData_
+};s2.data.Primitive = function(value) {
+ s2.data.Data.call(this);
+ this.value_ = value
+};
+s2.data.Primitive.inherits(s2.data.Data);
+s2.data.Primitive.prototype.getAt = function(key) {
+ return s2.data.Null.getNull()
+};
+s2.data.Primitive.prototype.getProp = function(name) {
+ return s2.data.Null.getNull()
+};
+s2.data.Primitive.prototype.equals = function(other) {
+ if(other.getValue) {
+ return this.value_ == other.getValue()
+ }else {
+ return this.value_ == other
+ }
+};
+s2.data.Primitive.prototype.getValue = function() {
+ return this.value_
+};s2.data.Proxy = function(original) {
+ this.original_ = original
+};
+s2.data.Proxy.prototype.getProxiedObject = function() {
+ return this.original_
+};
+s2.data.Proxy.createProxyFunction = function(name) {
+ return function() {
+ var proxied = this.getProxiedObject();
+ return proxied[name].apply(proxied, arguments)
+ }
+};
+s2.data.Proxy.createPrototype = function() {
+ for(var name in s2.data.Data.prototype) {
+ s2.data.Proxy.prototype[name] = s2.data.Proxy.createProxyFunction(name)
+ }
+};
+s2.data.Proxy.createPrototype();s2.data.ChainingProxy = function(toProxy) {
+ s2.data.Proxy.call(this, toProxy)
+};
+s2.data.ChainingProxy.inherits(s2.data.Proxy);
+s2.data.ChainingProxy.prototype.getAt = function(key) {
+ var result = s2.data.Proxy.prototype.getAt.call(this, key);
+ return this.decorate_(result)
+};
+s2.data.ChainingProxy.prototype.getRoot = function() {
+ var result = s2.data.Proxy.prototype.getRoot.call(this);
+ return this.decorate_(result)
+};
+s2.data.ChainingProxy.prototype.getProp = function(name) {
+ var result = s2.data.Proxy.prototype.getProp.call(this, name);
+ return this.decorate_(result)
+};
+s2.data.ChainingProxy.prototype.decorate_ = function(result) {
+ if(result == null) {
+ return s2.data.Null.getNull()
+ }else if(!goog.isObject(result)) {
+ return new s2.data.Primitive(result)
+ }else {
+ return new s2.data.ChainingProxy(result)
+ }
+};s2.data.Ref = function(type, id) {
+ s2.data.Proxy.call(this, null);
+ this.type_ = type;
+ this.id_ = id
+};
+s2.data.Ref.inherits(s2.data.Proxy);
+s2.data.Ref.prototype.getProxiedObject = function() {
+ return s2.data.Repository.getRepositoryByType(this.type_, this.getRoot()).getAt(this.id_)
+};
+s2.data.Ref.prototype.getRoot = function() {
+ if(this.parent_) {
+ return this.parent_.getRoot()
+ }else {
+ return s2.data.Root.getGlobal()
+ }
+};
+s2.data.Ref.prototype.getParent = function() {
+ return this.parent_
+};
+s2.data.Ref.prototype.setParent = function(parent) {
+ this.parent_ = parent
+};
+s2.data.Ref.prototype.isRef = function() {
+ return true
+};
+s2.data.Ref.prototype.toString = function() {
+ return this.type_ + ": " + this.id_
+};
+s2.data.Ref.Field = {Type:"Type", Id:"Id"};
+s2.data.Ref.canCreateReference = function(obj) {
+ return obj && obj[s2.data.Ref.Field.Type] && obj[s2.data.Ref.Field.Id]
+};
+s2.data.Ref.createRef = function(obj) {
+ var dataRef = new s2.data.Ref(obj[s2.data.Ref.Field.Type], obj[s2.data.Ref.Field.Id]);
+ obj[s2.data.DATA_PROP] = dataRef;
+ return dataRef
+};s2.data.ArrayWrapper = function(array) {
+ this.array_ = array;
+ this.array_[s2.data.DATA_PROP] = this
+};
+s2.data.ArrayWrapper.inherits(s2.data.Data);
+s2.data.ArrayWrapper.prototype.isCollection = function() {
+ return true
+};
+s2.data.ArrayWrapper.prototype.each = function(fn) {
+ var len = this.array_.length;
+ for(var i = 0;i < len;i++) {
+ var value = this.array_[i];
+ fn(s2.data.fromParent(value, this), i)
+ }
+};
+s2.data.ArrayWrapper.prototype.getAt = function(key) {
+ return s2.data.fromParent(this.array_[key], this)
+};
+s2.data.ArrayWrapper.prototype.putAt = function(key, value) {
+ if(value.setParent) {
+ value.setParent(this)
+ }this.array_[key] = s2.data.from(value)
+};
+s2.data.ArrayWrapper.prototype.removeAt = function(key) {
+ this.array_.splice(key, 1)
+};
+s2.data.ArrayWrapper.prototype.getProp = function(name) {
+ var results = [];
+ this.each(function(value, key) {
+ if(value.getProp) {
+ var prop = value.getProp(name);
+ if(prop) {
+ if(prop.isCollection && prop.isCollection()) {
+ prop.each(function(value) {
+ results.push(value)
+ })
+ }else {
+ results.push(prop)
+ }
+ }
+ }
+ });
+ return new s2.data.ArrayWrapper(results)
+};
+s2.data.ArrayWrapper.prototype.newInstance = function() {
+ return new s2.data.ArrayWrapper([])
+};
+s2.data.ArrayWrapper.prototype.push = function(value) {
+ this.array_.push(s2.data.unwrapIfNeeded(value))
+};
+s2.data.ArrayWrapper.prototype.getParent = function() {
+ return s2.data.from(this.array_[s2.data.PARENT_PROP])
+};
+s2.data.ArrayWrapper.prototype.setParent = function(parent) {
+ this.array_[s2.data.PARENT_PROP] = s2.data.unwrapIfNeeded(parent)
+};s2.data.ObjectWrapper = function(obj) {
+ this.obj_ = obj;
+ this.obj_[s2.data.DATA_PROP] = this
+};
+s2.data.ObjectWrapper.inherits(s2.data.Data);
+s2.data.ObjectWrapper.prototype.newInstance = function() {
+ return new s2.data.ObjectWrapper({})
+};
+s2.data.ObjectWrapper.prototype.eachProp = function(fn) {
+ for(var name in this.obj_) {
+ var value = this.obj_[name];
+ if(name != s2.data.DATA_PROP && name != s2.data.PARENT_PROP && !goog.isFunction(value)) {
+ fn(name, s2.data.fromParent(value, this))
+ }
+ }
+};
+s2.data.ObjectWrapper.prototype.getProp = function(name) {
+ var value = this.obj_[name];
+ if(name != s2.data.DATA_PROP && name != s2.data.PARENT_PROP && !goog.isFunction(value)) {
+ return s2.data.fromParent(value, this)
+ }return null
+};
+s2.data.ObjectWrapper.prototype.removeProp = function(name) {
+ delete this.obj_[name]
+};
+s2.data.ObjectWrapper.prototype.putProp = function(name, value) {
+ if(value.setParent) {
+ value.setParent(this)
+ }this.obj_[name] = s2.data.unwrapIfNeeded(value)
+};
+s2.data.ObjectWrapper.prototype.getParent = function() {
+ return s2.data.from(this.obj_[s2.data.PARENT_PROP])
+};
+s2.data.ObjectWrapper.prototype.setParent = function(parent) {
+ this.obj_[s2.data.PARENT_PROP] = s2.data.unwrapIfNeeded(parent)
+};s2.data.Repository = function(name, type, opt_parent) {
+ var parent = opt_parent || s2.data.Root.getGlobal();
+ this.name_ = name;
+ this.parent_ = parent;
+ this.type_ = type;
+ this.instances_ = {};
+ if(this.parent_.getProp(name)) {
+ return this.parent_.getProp(name)
+ }this.parent_.putProp(name, this);
+ s2.data.Repository.getTypeMapRoot_(this.parent_).putProp(type, this)
+};
+s2.data.Repository.inherits(s2.data.Data);
+s2.data.Repository.getRepositoryByType = function(type, opt_root) {
+ var root = opt_root || s2.data.getGlobalRoot();
+ return s2.data.Repository.getTypeMapRoot_(root).getProp(type)
+};
+s2.data.Repository.getTypeMapRoot_ = function(root) {
+ var map = root.getProp("DataStores");
+ if(!map) {
+ root.putProp("DataStores", s2.data.from({}));
+ map = root.getProp("DataStores")
+ }return map
+};
+s2.data.Repository.prototype.getAt = function(key) {
+ return s2.data.fromParent(this.instances_[key], this)
+};
+s2.data.Repository.prototype.putAt = function(key, value) {
+ if(value.setParent) {
+ value.setParent(this)
+ }this.instances_[key] = value
+};
+s2.data.Repository.prototype.removeAt = function(key) {
+ var value = this.instances_[key];
+ if(value && value.setParent) {
+ value.setParent(null)
+ }delete this.instances_[key]
+};
+s2.data.Repository.prototype.getParent = function() {
+ return this.parent_
+};
+s2.data.Repository.prototype.setParent = function(parent) {
+ this.parent_ = parent
+};
+s2.data.Repository.prototype.each = function(fn) {
+ for(var type in this.instances_) {
+ fn(this.instances_[type], type)
+ }
+};s2.data.Root = function() {
+ s2.data.ObjectWrapper.call(this, {})
+};
+s2.data.Root.inherits(s2.data.ObjectWrapper);
+s2.data.Root.prototype.getRoot = function() {
+ return this
+};
+s2.data.Root.globalInstance_ = null;
+s2.data.Root.getGlobal = function() {
+ if(!s2.data.Root.globalInstance_) {
+ s2.data.Root.globalInstance_ = new s2.data.Root
+ }return s2.data.Root.globalInstance_
+};
+s2.data.Root.clear = function() {
+ s2.data.Root.globalInstance_ = new s2.data.Root
+};goog.array = {};
+goog.array.peek = function(array) {
+ return array[array.length - 1]
+};
+goog.array.indexOf = function(arr, obj, opt_fromIndex) {
+ if(arr.indexOf) {
+ return arr.indexOf(obj, opt_fromIndex)
+ }if(Array.indexOf) {
+ return Array.indexOf(arr, obj, opt_fromIndex)
+ }if(opt_fromIndex == null) {
+ opt_fromIndex = 0
+ }else if(opt_fromIndex < 0) {
+ opt_fromIndex = Math.max(0, arr.length + opt_fromIndex)
+ }for(var i = opt_fromIndex;i < arr.length;i++) {
+ if(i in arr && arr[i] === obj)return i
+ }return-1
+};
+goog.array.lastIndexOf = function(arr, obj, opt_fromIndex) {
+ if(opt_fromIndex == null) {
+ opt_fromIndex = arr.length - 1
+ }if(arr.lastIndexOf) {
+ return arr.lastIndexOf(obj, opt_fromIndex)
+ }if(Array.lastIndexOf) {
+ return Array.lastIndexOf(arr, obj, opt_fromIndex)
+ }if(opt_fromIndex < 0) {
+ opt_fromIndex = Math.max(0, arr.length + opt_fromIndex)
+ }for(var i = opt_fromIndex;i >= 0;i--) {
+ if(i in arr && arr[i] === obj)return i
+ }return-1
+};
+goog.array.forEach = function(arr, f, opt_obj) {
+ if(arr.forEach) {
+ arr.forEach(f, opt_obj)
+ }else if(Array.forEach) {
+ Array.forEach(arr, f, opt_obj)
+ }else {
+ var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = 0;i < l;i++) {
+ if(i in arr2) {
+ f.call(opt_obj, arr2[i], i, arr)
+ }
+ }
+ }
+};
+goog.array.forEachRight = function(arr, f, opt_obj) {
+ var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = l - 1;i >= 0;--i) {
+ if(i in arr2) {
+ f.call(opt_obj, arr2[i], i, arr)
+ }
+ }
+};
+goog.array.filter = function(arr, f, opt_obj) {
+ if(arr.filter) {
+ return arr.filter(f, opt_obj)
+ }if(Array.filter) {
+ return Array.filter(arr, f, opt_obj)
+ }var l = arr.length, res = [], arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = 0;i < l;i++) {
+ if(i in arr2) {
+ var val = arr2[i];
+ if(f.call(opt_obj, val, i, arr)) {
+ res.push(val)
+ }
+ }
+ }return res
+};
+goog.array.map = function(arr, f, opt_obj) {
+ if(arr.map) {
+ return arr.map(f, opt_obj)
+ }if(Array.map) {
+ return Array.map(arr, f, opt_obj)
+ }var l = arr.length, res = [], arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = 0;i < l;i++) {
+ if(i in arr2) {
+ res.push(f.call(opt_obj, arr2[i], i, arr))
+ }
+ }return res
+};
+goog.array.reduce = function(arr, f, val, opt_obj) {
+ if(arr.reduce) {
+ if(opt_obj) {
+ return arr.reduce(goog.bind(f, opt_obj), val)
+ }else {
+ return arr.reduce(f, val)
+ }
+ }var rval = val;
+ goog.array.forEach(arr, function(val, index) {
+ rval = f.call(opt_obj, rval, val, index, arr)
+ });
+ return rval
+};
+goog.array.reduceRight = function(arr, f, val, opt_obj) {
+ if(arr.reduceRight) {
+ if(opt_obj) {
+ return arr.reduceRight(goog.bind(f, opt_obj), val)
+ }else {
+ return arr.reduceRight(f, val)
+ }
+ }var rval = val;
+ goog.array.forEachRight(arr, function(val, index) {
+ rval = f.call(opt_obj, rval, val, index, arr)
+ });
+ return rval
+};
+goog.array.some = function(arr, f, opt_obj) {
+ if(arr.some) {
+ return arr.some(f, opt_obj)
+ }if(Array.some) {
+ return Array.some(arr, f, opt_obj)
+ }var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = 0;i < l;i++) {
+ if(i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+ return true
+ }
+ }return false
+};
+goog.array.every = function(arr, f, opt_obj) {
+ if(arr.every) {
+ return arr.every(f, opt_obj)
+ }if(Array.every) {
+ return Array.every(arr, f, opt_obj)
+ }var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr;
+ for(var i = 0;i < l;i++) {
+ if(i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) {
+ return false
+ }
+ }return true
+};
+goog.array.contains = function(arr, obj) {
+ if(arr.contains) {
+ return arr.contains(obj)
+ }return goog.array.indexOf(arr, obj) > -1
+};
+goog.array.isEmpty = function(arr) {
+ return arr.length == 0
+};
+goog.array.clear = function(arr) {
+ if(!goog.isArray(arr)) {
+ for(var i = arr.length - 1;i >= 0;i--) {
+ delete arr[i]
+ }
+ }arr.length = 0
+};
+goog.array.insert = function(arr, obj) {
+ if(!goog.array.contains(arr, obj)) {
+ arr.push(obj)
+ }
+};
+goog.array.insertAt = function(arr, obj, opt_i) {
+ goog.array.splice(arr, opt_i, 0, obj)
+};
+goog.array.insertBefore = function(arr, obj, opt_obj2) {
+ var i;
+ if(arguments.length == 2 || (i = goog.array.indexOf(arr, opt_obj2)) == -1) {
+ arr.push(obj)
+ }else {
+ goog.array.insertAt(arr, obj, i)
+ }
+};
+goog.array.remove = function(arr, obj) {
+ var i = goog.array.indexOf(arr, obj), rv;
+ if(rv = i != -1) {
+ goog.array.removeAt(arr, i)
+ }return rv
+};
+goog.array.removeAt = function(arr, i) {
+ return Array.prototype.splice.call(arr, i, 1).length == 1
+};
+goog.array.clone = function(arr) {
+ if(goog.isArray(arr)) {
+ return arr.concat()
+ }else {
+ var rv = [];
+ for(var i = 0, len = arr.length;i < len;i++) {
+ rv[i] = arr[i]
+ }return rv
+ }
+};
+goog.array.toArray = function(object) {
+ if(goog.isArray(object)) {
+ return object.concat()
+ }return goog.array.clone(object)
+};
+goog.array.extend = function(arr1, var_args) {
+ for(var i = 1;i < arguments.length;i++) {
+ var arr2 = arguments[i];
+ if(!goog.isArray(arr2)) {
+ arr1.push(arr2)
+ }else {
+ arr1.push.apply(arr1, arr2)
+ }
+ }
+};
+goog.array.splice = function(arr, index, howMany, opt_el) {
+ return Array.prototype.splice.apply(arr, goog.array.slice(arguments, 1))
+};
+goog.array.slice = function(arr, start, opt_end) {
+ if(arguments.length <= 2) {
+ return Array.prototype.slice.call(arr, start)
+ }else {
+ return Array.prototype.slice.call(arr, start, opt_end)
+ }
+};
+goog.array.find = goog.array.indexOf;
+goog.array.insertValue = goog.array.insert;
+goog.array.deleteValue = goog.array.remove;
+goog.array.removeDuplicates = function(arr, opt_rv) {
+ var rv = opt_rv || arr, seen = {}, cursorInsert = 0, cursorRead = 0;
+ while(cursorRead < arr.length) {
+ var current = arr[cursorRead++], hc = goog.isObject(current) ? goog.getHashCode(current) : current;
+ if(!(hc in seen)) {
+ seen[hc] = true;
+ rv[cursorInsert++] = current
+ }
+ }rv.length = cursorInsert
+};
+goog.array.binarySearch = function(arr, target, opt_compareFn) {
+ var left = 0, right = arr.length - 1, compareFn = opt_compareFn || goog.array.defaultCompare;
+ while(left <= right) {
+ var mid = left + right >> 1, compareResult = compareFn(target, arr[mid]);
+ if(compareResult > 0) {
+ left = mid + 1
+ }else if(compareResult < 0) {
+ right = mid - 1
+ }else {
+ return mid
+ }
+ }return-(left + 1)
+};
+goog.array.sort = function(arr, opt_compareFn) {
+ Array.prototype.sort.call(arr, opt_compareFn || goog.array.defaultCompare)
+};
+goog.array.defaultCompare = function(a, b) {
+ return a > b ? 1 : (a < b ? -1 : 0)
+};
+goog.array.binaryInsert = function(array, value, opt_compareFn) {
+ var index = goog.array.binarySearch(array, value, opt_compareFn);
+ if(index < 0) {
+ goog.array.insertAt(array, value, -(index + 1));
+ return true
+ }return false
+};
+goog.array.binaryRemove = function(array, value, opt_compareFn) {
+ var index = goog.array.binarySearch(array, value, opt_compareFn);
+ return index >= 0 ? goog.array.removeAt(array, index) : false
+};goog.object = {};
+goog.object.forEach = function(obj, f, opt_obj) {
+ for(var key in obj) {
+ f.call(opt_obj, obj[key], key, obj)
+ }
+};
+goog.object.filter = function(obj, f, opt_obj) {
+ var res = {};
+ for(var key in obj) {
+ if(f.call(opt_obj, obj[key], key, obj)) {
+ res[key] = obj[key]
+ }
+ }return res
+};
+goog.object.map = function(obj, f, opt_obj) {
+ var res = {};
+ for(var key in obj) {
+ res[key] = f.call(opt_obj, obj[key], key, obj)
+ }return res
+};
+goog.object.some = function(obj, f, opt_obj) {
+ for(var key in obj) {
+ if(f.call(opt_obj, obj[key], key, obj)) {
+ return true
+ }
+ }return false
+};
+goog.object.every = function(obj, f, opt_obj) {
+ for(var key in obj) {
+ if(!f.call(opt_obj, obj[key], key, obj)) {
+ return false
+ }
+ }return true
+};
+goog.object.getCount = function(obj) {
+ var rv = 0;
+ for(var key in obj) {
+ rv++
+ }return rv
+};
+goog.object.contains = function(obj, val) {
+ return goog.object.containsValue(obj, val)
+};
+goog.object.getValues = function(obj) {
+ var res = [];
+ for(var key in obj) {
+ res.push(obj[key])
+ }return res
+};
+goog.object.getKeys = function(obj) {
+ var res = [];
+ for(var key in obj) {
+ res.push(key)
+ }return res
+};
+goog.object.containsKey = function(obj, key) {
+ return key in obj
+};
+goog.object.containsValue = function(obj, val) {
+ for(var key in obj) {
+ if(obj[key] == val) {
+ return true
+ }
+ }return false
+};
+goog.object.isEmpty = function(obj) {
+ for(var key in obj) {
+ return false
+ }return true
+};
+goog.object.clear = function(obj) {
+ var keys = goog.object.getKeys(obj);
+ for(var i = keys.length - 1;i >= 0;i--) {
+ goog.object.remove(obj, keys[i])
+ }
+};
+goog.object.remove = function(obj, key) {
+ var rv;
+ if(rv = key in obj) {
+ delete obj[key]
+ }return rv
+};
+goog.object.add = function(obj, key, val) {
+ if(key in obj) {
+ throw Error('The object already contains the key "' + key + '"');
+ }goog.object.set(obj, key, val)
+};
+goog.object.get = function(obj, key, opt_val) {
+ if(key in obj) {
+ return obj[key]
+ }return opt_val
+};
+goog.object.set = function(obj, key, value) {
+ obj[key] = value
+};
+goog.object.clone = function(obj) {
+ var res = {};
+ for(var key in obj) {
+ res[key] = obj[key]
+ }return res
+};
+goog.object.transpose = function(obj) {
+ var transposed = {}, keys = goog.object.getKeys(obj);
+ for(var i = 0, len = keys.length;i < len;i++) {
+ var key = keys[i];
+ transposed[obj[key]] = key
+ }return transposed
+};
+goog.object.PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+goog.object.extend = function(target, var_args) {
+ var key, source;
+ for(var i = 1;i < arguments.length;i++) {
+ source = arguments[i];
+ for(key in source) {
+ target[key] = source[key]
+ }for(var j = 0;j < goog.object.PROTOTYPE_FIELDS_.length;j++) {
+ key = goog.object.PROTOTYPE_FIELDS_[j];
+ if(Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+};goog.string = {};
+goog.string.startsWith = function(str, prefix) {
+ return str.indexOf(prefix) == 0
+};
+goog.string.endsWith = function(str, suffix) {
+ var l = str.length - suffix.length;
+ return l >= 0 && str.lastIndexOf(suffix, l) == l
+};
+goog.string.subs = function(str) {
+ for(var i = 1;i < arguments.length;i++) {
+ var replacement = String(arguments[i]).replace(/\$/g, "$$$$");
+ str = str.replace(/\%s/, replacement)
+ }return str
+};
+goog.string.collapseWhitespace = function(str) {
+ return str.replace(/\s+/g, " ").replace(/^\s+|\s+$/g, "")
+};
+goog.string.isEmpty = function(str) {
+ return/^\s*$/.test(str)
+};
+goog.string.isEmptySafe = function(str) {
+ return goog.string.isEmpty(goog.string.makeSafe(str))
+};
+goog.string.isAlpha = function(str) {
+ return!/[^a-zA-Z]/.test(str)
+};
+goog.string.isNumeric = function(str) {
+ return!/[^0-9]/.test(str)
+};
+goog.string.isAlphaNumeric = function(str) {
+ return!/[^a-zA-Z0-9]/.test(str)
+};
+goog.string.isSpace = function(ch) {
+ return ch == " "
+};
+goog.string.isUnicodeChar = function(ch) {
+ return ch.length == 1 && ch >= " " && ch <= "~" || ch >= "\u0080" && ch <= "\ufffd"
+};
+goog.string.stripNewlines = function(str) {
+ return str.replace(/(\r\n|\r|\n)+/g, " ")
+};
+goog.string.canonicalizeNewlines = function(str) {
+ return str.replace(/(\r\n|\r|\n)/g, "\n")
+};
+goog.string.normalizeWhitespace = function(str) {
+ return str.replace(/\xa0|\s/g, " ")
+};
+goog.string.normalizeSpaces = function(str) {
+ return str.replace(/\xa0|[ \t]+/g, " ")
+};
+goog.string.trim = function(str) {
+ return str.replace(/^\s+|\s+$/g, "")
+};
+goog.string.trimLeft = function(str) {
+ return str.replace(/^\s+/, "")
+};
+goog.string.trimRight = function(str) {
+ return str.replace(/\s+$/, "")
+};
+goog.string.caseInsensitiveCompare = function(str1, str2) {
+ var test1 = String(str1).toLowerCase(), test2 = String(str2).toLowerCase();
+ if(test1 < test2) {
+ return-1
+ }else if(test1 == test2) {
+ return 0
+ }else {
+ return 1
+ }
+};
+goog.string.numerateCompareRegExp_ = /(\.\d+)|(\d+)|(\D+)/g;
+goog.string.numerateCompare = function(str1, str2) {
+ if(str1 == str2) {
+ return 0
+ }if(!str1) {
+ return-1
+ }if(!str2) {
+ return 1
+ }var tokens1 = str1.toLowerCase().match(goog.string.numerateCompareRegExp_), tokens2 = str2.toLowerCase().match(goog.string.numerateCompareRegExp_), count = Math.min(tokens1.length, tokens2.length);
+ for(var i = 0;i < count;i++) {
+ var a = tokens1[i], b = tokens2[i];
+ if(a != b) {
+ var num1 = parseInt(a, 10);
+ if(!isNaN(num1)) {
+ var num2 = parseInt(b, 10);
+ if(!isNaN(num2) && num1 - num2) {
+ return num1 - num2
+ }
+ }return a < b ? -1 : 1
+ }
+ }if(tokens1.length != tokens2.length) {
+ return tokens1.length - tokens2.length
+ }return str1 < str2 ? -1 : 1
+};
+goog.string.encodeUriRegExp_ = /^[a-zA-Z0-9\-_.!~*'()]*$/;
+goog.string.urlEncode = function(str) {
+ str = String(str);
+ if(!goog.string.encodeUriRegExp_.test(str)) {
+ return encodeURIComponent(str)
+ }return str
+};
+goog.string.urlDecode = function(str) {
+ return decodeURIComponent(str.replace(/\+/g, " "))
+};
+goog.string.newLineToBr = function(str, opt_xml) {
+ return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>")
+};
+goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
+ if(opt_isLikelyToContainHtmlChars) {
+ return str.replace(goog.string.amperRe_, goog.string.amperStrRepl_).replace(goog.string.ltRe_, goog.string.ltStrRepl_).replace(goog.string.gtRe_, goog.string.gtStrRepl_).replace(goog.string.quotRe_, goog.string.quotStrRepl_)
+ }else {
+ if(!goog.string.allRe_.test(str))return str;
+ if(str.indexOf(goog.string.amperStrOrig_) != -1) {
+ str = str.replace(goog.string.amperRe_, goog.string.amperStrRepl_)
+ }if(str.indexOf(goog.string.ltStrOrig_) != -1) {
+ str = str.replace(goog.string.ltRe_, goog.string.ltStrRepl_)
+ }if(str.indexOf(goog.string.gtStrOrig_) != -1) {
+ str = str.replace(goog.string.gtRe_, goog.string.gtStrRepl_)
+ }if(str.indexOf(goog.string.quotStrOrig_) != -1) {
+ str = str.replace(goog.string.quotRe_, goog.string.quotStrRepl_)
+ }return str
+ }
+};
+goog.string.amperStrOrig_ = "&";
+goog.string.ltStrOrig_ = "<";
+goog.string.gtStrOrig_ = ">";
+goog.string.quotStrOrig_ = '"';
+goog.string.amperStrRepl_ = "&";
+goog.string.ltStrRepl_ = "<";
+goog.string.gtStrRepl_ = ">";
+goog.string.quotStrRepl_ = """;
+goog.string.amperRe_ = /&/g;
+goog.string.ltRe_ = /</g;
+goog.string.gtRe_ = />/g;
+goog.string.quotRe_ = /\"/g;
+goog.string.allRe_ = /[&<>\"]/;
+goog.string.unescapeEntities = function(str) {
+ if(goog.string.contains(str, "&")) {
+ if("document" in goog.global && !goog.string.contains(str, "<")) {
+ var el = goog.global.document.createElement("a");
+ el.innerHTML = str;
+ if(el[goog.string.NORMALIZE_FN_]) {
+ el[goog.string.NORMALIZE_FN_]()
+ }str = el.firstChild.nodeValue;
+ el.innerHTML = ""
+ }else {
+ return str.replace(/&([^;]+);/g, function(s, entity) {
+ switch(entity) {
+ case "amp":
+ return"&";
+ case "lt":
+ return"<";
+ case "gt":
+ return">";
+ case "quot":
+ return'"';
+ default:
+ if(entity.charAt(0) == "#") {
+ var n = Number("0" + entity.substr(1));
+ if(!isNaN(n)) {
+ return String.fromCharCode(n)
+ }
+ }return s
+ }
+ })
+ }
+ }return str
+};
+goog.string.NORMALIZE_FN_ = "normalize";
+goog.string.whitespaceEscape = function(str, opt_xml) {
+ return goog.string.newLineToBr(str.replace(/ /g, "  "), opt_xml)
+};
+goog.string.stripQuotes = function(str, quotechar) {
+ if(str.charAt(0) == quotechar && str.charAt(str.length - 1) == quotechar) {
+ return str.substring(1, str.length - 1)
+ }return str
+};
+goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
+ if(opt_protectEscapedCharacters) {
+ str = goog.string.unescapeEntities(str)
+ }if(str.length > chars) {
+ str = str.substring(0, chars - 3) + "..."
+ }if(opt_protectEscapedCharacters) {
+ str = goog.string.htmlEscape(str)
+ }return str
+};
+goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters) {
+ if(opt_protectEscapedCharacters) {
+ str = goog.string.unescapeEntities(str)
+ }if(str.length > chars) {
+ var half = Math.floor(chars / 2), endPos = str.length - half;
+ half += chars % 2;
+ str = str.substring(0, half) + "..." + str.substring(endPos)
+ }if(opt_protectEscapedCharacters) {
+ str = goog.string.htmlEscape(str)
+ }return str
+};
+goog.string.jsEscapeCache_ = {"\u0008":"\\b", "\u000c":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\u000b":"\\x0B", '"':'\\"', "'":"\\'", "\\":"\\\\"};
+goog.string.quote = function(s) {
+ s = String(s);
+ if(s.quote) {
+ return s.quote()
+ }else {
+ var rv = '"';
+ for(var i = 0;i < s.length;i++) {
+ rv += goog.string.escapeChar(s.charAt(i))
+ }return rv + '"'
+ }
+};
+goog.string.escapeChar = function(c) {
+ if(c in goog.string.jsEscapeCache_) {
+ return goog.string.jsEscapeCache_[c]
+ }var rv = c, cc = c.charCodeAt(0);
+ if(cc > 31 && cc < 127) {
+ rv = c
+ }else {
+ if(cc < 256) {
+ rv = "\\x";
+ if(cc < 16 || cc > 256) {
+ rv += "0"
+ }
+ }else {
+ rv = "\\u";
+ if(cc < 4096) {
+ rv += "0"
+ }
+ }rv += cc.toString(16).toUpperCase()
+ }return goog.string.jsEscapeCache_[c] = rv
+};
+goog.string.toMap = function(s) {
+ var rv = {};
+ for(var i = 0;i < s.length;i++) {
+ rv[s.charAt(i)] = true
+ }return rv
+};
+goog.string.JS_REG_EXP_ESCAPE_CHAR_MAP_ = goog.string.toMap("()[]{}+-?*.$^|,:#<!\\");
+goog.string.contains = function(s, ss) {
+ return s.indexOf(ss) != -1
+};
+goog.string.regExpEscape = function(s) {
+ s = String(s);
+ var rv = "", c;
+ for(var i = 0;i < s.length;i++) {
+ c = s.charAt(i);
+ if(c == "\u0008") {
+ c = "\\x08"
+ }else if(c in goog.string.JS_REG_EXP_ESCAPE_CHAR_MAP_) {
+ c = "\\" + c
+ }rv += c
+ }return rv
+};
+goog.string.repeat = function(string, length) {
+ return(new Array(length + 1)).join(string)
+};
+goog.string.padNumber = function(num, length, opt_precision) {
+ var i = Math.floor(num), s = String(i);
+ return goog.string.repeat("0", Math.max(0, length - s.length)) + (goog.isDef(opt_precision) ? num.toFixed(opt_precision) : num)
+};
+goog.string.makeSafe = function(obj) {
+ return obj == null ? "" : String(obj)
+};
+goog.string.buildString = function() {
+ return Array.prototype.join.call(arguments, "")
+};
+goog.string.getRandomString = function() {
+ return Math.floor(Math.random() * 2147483648).toString(36) + (Math.floor(Math.random() * 2147483648) ^ (new Date).getTime()).toString(36)
+};
+goog.string.compareVersions = function(version1, version2) {
+ var order = 0, v1Subs = String(version1).split("."), v2Subs = String(version2).split("."), subCount = Math.max(v1Subs.length, v2Subs.length);
+ for(var subIdx = 0;order == 0 && subIdx < subCount;subIdx++) {
+ var v1Sub = v1Subs[subIdx] || "", v2Sub = v2Subs[subIdx] || "", v1CompParser = new RegExp("(\\d*)(\\D*)", "g"), v2CompParser = new RegExp("(\\d*)(\\D*)", "g");
+ do {
+ var v1Comp = v1CompParser.exec(v1Sub) || ["", "", ""], v2Comp = v2CompParser.exec(v2Sub) || ["", "", ""];
+ if(v1Comp[0].length == 0 && v2Comp[0].length == 0) {
+ break
+ }var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10), v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
+ order = goog.string.compareElements_(v1CompNum, v2CompNum) || goog.string.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.compareElements_(v1Comp[2], v2Comp[2])
+ }while(order == 0)
+ }return order
+};
+goog.string.compareElements_ = function(left, right) {
+ if(left < right) {
+ return-1
+ }else if(left > right) {
+ return 1
+ }return 0
+};goog.math = {};
+goog.math.randomInt = function(a) {
+ return Math.floor(Math.random() * a)
+};
+goog.math.uniformRandom = function(a, b) {
+ return a + Math.random() * (b - a)
+};
+goog.math.clamp = function(value, min, max) {
+ return Math.min(Math.max(value, min), max)
+};
+goog.math.modulo = function(a, b) {
+ var r = a % b;
+ return r * b < 0 ? r + b : r
+};
+goog.math.lerp = function(a, b, x) {
+ return a + x * (b - a)
+};
+goog.math.nearlyEquals = function(a, b, opt_tolerance) {
+ return Math.abs(a - b) <= (opt_tolerance || 1.0E-6)
+};
+goog.math.Size = function(opt_w, opt_h) {
+ this.width = goog.isDef(opt_w) ? Number(opt_w) : undefined;
+ this.height = goog.isDef(opt_h) ? Number(opt_h) : undefined
+};
+goog.math.Size.prototype.clone = function() {
+ return new goog.math.Size(this.width, this.height)
+};
+goog.math.Size.prototype.toString = function() {
+ return"(" + this.width + " x " + this.height + ")"
+};
+goog.math.Size.equals = function(a, b) {
+ if(a == b) {
+ return true
+ }if(!a || !b) {
+ return false
+ }return a.width == b.width && a.height == b.height
+};
+goog.math.Coordinate = function(opt_x, opt_y) {
+ this.x = goog.isDef(opt_x) ? Number(opt_x) : undefined;
+ this.y = goog.isDef(opt_y) ? Number(opt_y) : undefined
+};
+goog.math.Coordinate.prototype.clone = function() {
+ return new goog.math.Coordinate(this.x, this.y)
+};
+goog.math.Coordinate.prototype.toString = function() {
+ return"(" + this.x + ", " + this.y + ")"
+};
+goog.math.Coordinate.equals = function(a, b) {
+ if(a == b) {
+ return true
+ }if(!a || !b) {
+ return false
+ }return a.x == b.x && a.y == b.y
+};
+goog.math.Coordinate.distance = function(a, b) {
+ var dx = a.x - b.x, dy = a.y - b.y;
+ return Math.sqrt(dx * dx + dy * dy)
+};
+goog.math.Coordinate.squaredDistance = function(a, b) {
+ var dx = a.x - b.x, dy = a.y - b.y;
+ return dx * dx + dy * dy
+};
+goog.math.Coordinate.difference = function(a, b) {
+ return new goog.math.Coordinate(a.x - b.x, a.y - b.y)
+};
+goog.math.Range = function(a, b) {
+ a = Number(a);
+ b = Number(b);
+ this.start = a < b ? a : b;
+ this.end = a < b ? b : a
+};
+goog.math.Range.prototype.clone = function() {
+ return new goog.math.Range(this.start, this.end)
+};
+goog.math.Range.prototype.toString = function() {
+ return"[" + this.start + ", " + this.end + "]"
+};
+goog.math.Range.equals = function(a, b) {
+ if(a == b) {
+ return true
+ }if(!a || !b) {
+ return false
+ }return a.start == b.start && a.end == b.end
+};
+goog.math.Range.intersection = function(a, b) {
+ var c0 = Math.max(a.start, b.start), c1 = Math.min(a.end, b.end);
+ return c0 <= c1 ? new goog.math.Range(c0, c1) : null
+};
+goog.math.Range.boundingRange = function(a, b) {
+ return new goog.math.Range(Math.min(a.start, b.start), Math.max(a.end, b.end))
+};
+goog.math.Range.contains = function(a, b) {
+ return a.start <= b.start && a.end >= b.end
+};
+goog.math.Rect = function(opt_x, opt_y, opt_w, opt_h) {
+ this.left = goog.isDef(opt_x) ? Number(opt_x) : undefined;
+ this.top = goog.isDef(opt_y) ? Number(opt_y) : undefined;
+ this.width = goog.isDef(opt_w) ? Number(opt_w) : undefined;
+ this.height = goog.isDef(opt_h) ? Number(opt_h) : undefined
+};
+goog.math.Rect.prototype.clone = function() {
+ return new goog.math.Rect(this.left, this.top, this.width, this.height)
+};
+goog.math.Rect.prototype.toBox = function() {
+ return new goog.math.Box(this.top, this.left + this.width || undefined, this.top + this.height || undefined, this.left)
+};
+goog.math.Rect.prototype.toString = function() {
+ return"(" + this.left + ", " + this.top + " - " + this.width + "w x " + this.height + "h)"
+};
+goog.math.Rect.equals = function(a, b) {
+ if(a == b) {
+ return true
+ }if(!a || !b) {
+ return false
+ }return a.left == b.left && a.width == b.width && a.top == b.top && a.height == b.height
+};
+goog.math.Rect.prototype.intersection = function(rect) {
+ var x0 = Math.max(this.left, rect.left), x1 = Math.min(this.left + this.width, rect.left + rect.width);
+ if(x0 <= x1) {
+ var y0 = Math.max(this.top, rect.top), y1 = Math.min(this.top + this.height, rect.top + rect.height);
+ if(y0 <= y1) {
+ this.left = x0;
+ this.top = y0;
+ this.width = x1 - x0;
+ this.height = y1 - y0;
+ return true
+ }
+ }return false
+};
+goog.math.Rect.intersection = function(a, b) {
+ var x0 = Math.max(a.left, b.left), x1 = Math.min(a.left + a.width, b.left + b.width);
+ if(x0 <= x1) {
+ var y0 = Math.max(a.top, b.top), y1 = Math.min(a.top + a.height, b.top + b.height);
+ if(y0 <= y1) {
+ return new goog.math.Rect(x0, y0, x1 - x0, y1 - y0)
+ }
+ }return null
+};
+goog.math.Rect.difference = function(a, b) {
+ if(!goog.math.Rect.intersection(a, b)) {
+ return[a.clone()]
+ }var result = [], top = a.top, height = a.height, ar = a.left + a.width, ab = a.top + a.height, br = b.left + b.width, bb = b.top + b.height;
+ if(b.top > a.top) {
+ result.push(new goog.math.Rect(a.left, a.top, a.width, b.top - a.top));
+ top = b.top
+ }if(bb < ab) {
+ result.push(new goog.math.Rect(a.left, bb, a.width, ab - bb));
+ height = bb - top
+ }if(b.left > a.left) {
+ result.push(new goog.math.Rect(a.left, top, b.left - a.left, height))
+ }if(br < ar) {
+ result.push(new goog.math.Rect(br, top, ar - br, height))
+ }return result
+};
+goog.math.Rect.prototype.difference = function(rect) {
+ return goog.math.Rect.difference(this, rect)
+};
+goog.math.Rect.prototype.boundingRect = function(rect) {
+ var right = Math.max(this.left + this.width, rect.left + rect.width), bottom = Math.max(this.top + this.height, rect.top + rect.height);
+ this.left = Math.min(this.left, rect.left);
+ this.top = Math.min(this.top, rect.top);
+ this.width = right - this.left;
+ this.height = bottom - this.top
+};
+goog.math.Rect.boundingRect = function(a, b) {
+ if(!a || !b) {
+ return null
+ }var clone = a.clone();
+ clone.boundingRect(b);
+ return clone
+};
+goog.math.Box = function(opt_top, opt_right, opt_bottom, opt_left) {
+ this.top = goog.isDef(opt_top) ? Number(opt_top) : undefined;
+ this.right = goog.isDef(opt_right) ? Number(opt_right) : undefined;
+ this.bottom = goog.isDef(opt_bottom) ? Number(opt_bottom) : undefined;
+ this.left = goog.isDef(opt_left) ? Number(opt_left) : undefined
+};
+goog.math.Box.boundingBox = function() {
+ var box = new goog.math.Box(arguments[0].y, arguments[0].x, arguments[0].y, arguments[0].x);
+ for(var i = 1;i < arguments.length;i++) {
+ var coord = arguments[i];
+ box.top = Math.min(box.top, coord.y);
+ box.right = Math.max(box.right, coord.x);
+ box.bottom = Math.max(box.bottom, coord.y);
+ box.left = Math.min(box.left, coord.x)
+ }return box
+};
+goog.math.Box.prototype.clone = function() {
+ return new goog.math.Box(this.top, this.right, this.bottom, this.left)
+};
+goog.math.Box.prototype.toRect = function() {
+ return new goog.math.Rect(this.left, this.top, this.right - this.left || undefined, this.bottom - this.top || undefined)
+};
+goog.math.Box.prototype.toString = function() {
+ return"(" + this.top + "t, " + this.right + "r, " + this.bottom + "b, " + this.left + "l)"
+};
+goog.math.Box.prototype.contains = function(coord) {
+ return goog.math.Box.contains(this, coord)
+};
+goog.math.Box.prototype.expand = function(top, opt_right, opt_bottom, opt_left) {
+ if(goog.isObject(top)) {
+ this.top -= top.top;
+ this.right += top.right;
+ this.bottom += top.bottom;
+ this.left -= top.left
+ }else {
+ this.top -= top;
+ this.right += opt_right;
+ this.bottom += opt_bottom;
+ this.left -= opt_left
+ }return this
+};
+goog.math.Box.equals = function(a, b) {
+ if(a == b) {
+ return true
+ }if(!a || !b) {
+ return false
+ }return a.top == b.top && a.right == b.right && a.bottom == b.bottom && a.left == b.left
+};
+goog.math.Box.contains = function(box, coord) {
+ if(!box || !coord) {
+ return false
+ }return coord.x >= box.left && coord.x <= box.right && coord.y >= box.top && coord.y <= box.bottom
+};
+goog.math.Box.distance = function(box, coord) {
+ if(coord.x >= box.left && coord.x <= box.right) {
+ if(coord.y >= box.top && coord.y <= box.bottom) {
+ return 0
+ }return coord.y < box.top ? box.top - coord.y : coord.y - box.bottom
+ }if(coord.y >= box.top && coord.y <= box.bottom) {
+ return coord.x < box.left ? box.left - coord.x : coord.x - box.right
+ }return goog.math.Coordinate.distance(coord, new goog.math.Coordinate(coord.x < box.left ? box.left : box.right, coord.y < box.top ? box.top : box.bottom))
+};
+goog.math.standardAngle = function(angle) {
+ return goog.math.modulo(angle, 360)
+};
+goog.math.toRadians = function(angleDegrees) {
+ return angleDegrees * Math.PI / 180
+};
+goog.math.toDegrees = function(angleRadians) {
+ return angleRadians * 180 / Math.PI
+};
+goog.math.angleDx = function(degrees, radius) {
+ return radius * Math.cos(goog.math.toRadians(degrees))
+};
+goog.math.angleDy = function(degrees, radius) {
+ return radius * Math.sin(goog.math.toRadians(degrees))
+};
+goog.math.angle = function(x1, y1, x2, y2) {
+ return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)))
+};
+goog.math.angleDifference = function(startAngle, endAngle) {
+ var d = goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);
+ if(d > 180) {
+ d = d - 360
+ }else if(d <= -180) {
+ d = 360 + d
+ }return d
+};goog.userAgent = {};
+(function() {
+ var isOpera = false, isIe = false, isSafari = false, isGecko = false, isCamino = false, isKonqueror = false, isKhtml = false, isMac = false, isWindows = false, isLinux = false, isMobile = false, platform = "";
+ if(goog.global.navigator) {
+ var ua = navigator.userAgent;
+ isOpera = typeof opera != "undefined";
+ isIe = !isOpera && ua.indexOf("MSIE") != -1;
+ isSafari = !isOpera && ua.indexOf("WebKit") != -1;
+ isMobile = isSafari && ua.indexOf("Mobile") != -1;
+ isGecko = !isOpera && navigator.product == "Gecko" && !isSafari;
+ isCamino = isGecko && navigator.vendor == "Camino";
+ isKonqueror = !isOpera && ua.indexOf("Konqueror") != -1;
+ isKhtml = isKonqueror || isSafari;
+ var version, re;
+ if(isOpera) {
+ version = opera.version()
+ }else {
+ if(isGecko) {
+ re = /rv\:([^\);]+)(\)|;)/
+ }else if(isIe) {
+ re = /MSIE\s+([^\);]+)(\)|;)/
+ }else if(isSafari) {
+ re = /WebKit\/(\S+)/
+ }else if(isKonqueror) {
+ re = /Konqueror\/([^\);]+)(\)|;)/
+ }if(re) {
+ re.test(ua);
+ version = RegExp.$1
+ }
+ }platform = navigator.platform;
+ isMac = platform.indexOf("Mac") != -1;
+ isWindows = platform.indexOf("Win") != -1;
+ isLinux = platform.indexOf("Linux") != -1
+ }goog.userAgent.OPERA = isOpera;
+ goog.userAgent.IE = isIe;
+ goog.userAgent.GECKO = isGecko;
+ goog.userAgent.CAMINO = isCamino;
+ goog.userAgent.KONQUEROR = isKonqueror;
+ goog.userAgent.SAFARI = isSafari;
+ goog.userAgent.KHTML = isKhtml;
+ goog.userAgent.VERSION = version;
+ goog.userAgent.PLATFORM = platform;
+ goog.userAgent.MAC = isMac;
+ goog.userAgent.WINDOWS = isWindows;
+ goog.userAgent.LINUX = isLinux;
+ goog.userAgent.MOBILE = isMobile
+})();
+goog.userAgent.compare = function(v1, v2) {
+ return goog.string.compareVersions(v1, v2)
+};
+goog.userAgent.isVersion = function(version) {
+ return goog.userAgent.compare(goog.userAgent.VERSION, version) >= 0
+};goog.dom = {};
+goog.dom.NodeType = {ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, ENTITY_REFERENCE:5, ENTITY:6, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9, DOCUMENT_TYPE:10, DOCUMENT_FRAGMENT:11, NOTATION:12};
+goog.dom.getDefaultDomHelper_ = function() {
+ if(!goog.dom.defaultDomHelper_) {
+ goog.dom.defaultDomHelper_ = new goog.dom.DomHelper
+ }return goog.dom.defaultDomHelper_
+};
+goog.dom.getDomHelper = function(opt_element) {
+ return opt_element ? new goog.dom.DomHelper(goog.dom.getOwnerDocument(opt_element)) : goog.dom.getDefaultDomHelper_()
+};
+goog.dom.getDocument = function() {
+ return goog.dom.getDefaultDomHelper_().getDocument()
+};
+goog.dom.getElement = function(element) {
+ return goog.dom.getDefaultDomHelper_().getElement(element)
+};
+goog.dom.$ = goog.dom.getElement;
+goog.dom.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
+ return goog.dom.getDefaultDomHelper_().getElementsByTagNameAndClass(opt_tag, opt_class, opt_el)
+};
+goog.dom.$$ = goog.dom.getElementsByTagNameAndClass;
+goog.dom.setProperties = function(element, properties) {
+ goog.object.forEach(properties, function(val, key) {
+ if(key == "style") {
+ element.style.cssText = val
+ }else if(key == "class") {
+ element.className = val
+ }else if(key == "for") {
+ element.htmlFor = val
+ }else if(key in goog.dom.DIRECT_ATTRIBUTE_MAP_) {
+ element.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[key], val)
+ }else {
+ element[key] = val
+ }
+ })
+};
+goog.dom.DIRECT_ATTRIBUTE_MAP_ = {cellpadding:"cellPadding", cellspacing:"cellSpacing", colspan:"colSpan", rowspan:"rowSpan", valign:"vAlign", height:"height", width:"width", usemap:"useMap", frameborder:"frameBorder"};
+goog.dom.getViewportSize = function(opt_window) {
+ var win = opt_window || goog.global || window, doc = win.document;
+ if(goog.userAgent.SAFARI && !goog.userAgent.isVersion("500") && !goog.userAgent.MOBILE) {
+ if(typeof win.innerHeight == "undefined") {
+ win = window
+ }var innerHeight = win.innerHeight, scrollHeight = win.document.documentElement.scrollHeight;
+ if(win == win.top) {
+ if(scrollHeight < innerHeight) {
+ innerHeight -= 15
+ }
+ }return new goog.math.Size(win.innerWidth, innerHeight)
+ }var dh = goog.dom.getDomHelper(doc), el = dh.getCompatMode() == "CSS1Compat" && (!goog.userAgent.OPERA || goog.userAgent.OPERA && goog.userAgent.isVersion("9.50")) ? doc.documentElement : doc.body;
+ return new goog.math.Size(el.clientWidth, el.clientHeight)
+};
+goog.dom.getPageScroll = function(opt_window) {
+ var win = opt_window || goog.global || window, doc = win.document, x, y;
+ if(!goog.userAgent.SAFARI && doc.compatMode == "CSS1Compat") {
+ x = doc.documentElement.scrollLeft;
+ y = doc.documentElement.scrollTop
+ }else {
+ x = doc.body.scrollLeft;
+ y = doc.body.scrollTop
+ }return new goog.math.Coordinate(x, y)
+};
+goog.dom.getWindow = function(doc) {
+ if(goog.userAgent.SAFARI && !goog.userAgent.isVersion("500") && !goog.userAgent.MOBILE) {
+ return null
+ }else {
+ return doc.parentWindow || doc.defaultView
+ }
+};
+goog.dom.createDom = function(tagName, opt_attributes) {
+ var dh = goog.dom.getDefaultDomHelper_();
+ return dh.createDom.apply(dh, arguments)
+};
+goog.dom.$dom = goog.dom.createDom;
+goog.dom.createElement = function(name) {
+ return goog.dom.getDefaultDomHelper_().createElement(name)
+};
+goog.dom.createTextNode = function(content) {
+ return goog.dom.getDefaultDomHelper_().createTextNode(content)
+};
+goog.dom.htmlToDocumentFragment = function(htmlString) {
+ return goog.dom.getDefaultDomHelper_().htmlToDocumentFragment(htmlString)
+};
+goog.dom.getCompatMode = function() {
+ return goog.dom.getDefaultDomHelper_().getCompatMode()
+};
+goog.dom.appendChild = function(parent, child) {
+ parent.appendChild(child)
+};
+goog.dom.removeChildren = function(node) {
+ var child;
+ while(child = node.firstChild) {
+ node.removeChild(child)
+ }
+};
+goog.dom.insertSiblingBefore = function(newNode, refNode) {
+ if(refNode.parentNode) {
+ refNode.parentNode.insertBefore(newNode, refNode)
+ }
+};
+goog.dom.insertSiblingAfter = function(newNode, refNode) {
+ if(refNode.parentNode) {
+ refNode.parentNode.insertBefore(newNode, refNode.nextSibling)
+ }
+};
+goog.dom.removeNode = function(node) {
+ return node && node.parentNode ? node.parentNode.removeChild(node) : null
+};
+goog.dom.getFirstElementChild = function(node) {
+ return goog.dom.getNextElementNode_(node.firstChild, true)
+};
+goog.dom.getLastElementChild = function(node) {
+ return goog.dom.getNextElementNode_(node.lastChild, false)
+};
+goog.dom.getNextElementSibling = function(node) {
+ return goog.dom.getNextElementNode_(node.nextSibling, true)
+};
+goog.dom.getPreviousElementSibling = function(node) {
+ return goog.dom.getNextElementNode_(node.previousSibling, false)
+};
+goog.dom.getNextElementNode_ = function(node, forward) {
+ while(node && node.nodeType != goog.dom.NodeType.ELEMENT) {
+ node = forward ? node.nextSibling : node.previousSibling
+ }return node
+};
+goog.dom.isNodeLike = function(obj) {
+ return goog.isObject(obj) && obj.nodeType > 0
+};
+goog.dom.BAD_CONTAINS_SAFARI_ = goog.userAgent.SAFARI && goog.userAgent.compare(goog.userAgent.VERSION, "521") <= 0;
+goog.dom.contains = function(parent, descendant) {
+ if(typeof parent.contains != "undefined" && !goog.dom.BAD_CONTAINS_SAFARI_ && descendant.nodeType == goog.dom.NodeType.ELEMENT) {
+ return parent == descendant || parent.contains(descendant)
+ }if(typeof parent.compareDocumentPosition != "undefined") {
+ return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16)
+ }while(descendant && parent != descendant) {
+ descendant = descendant.parentNode
+ }return descendant == parent
+};
+goog.dom.compareNodeOrder = function(node1, node2) {
+ if(node1 == node2) {
+ return 0
+ }if(node1.compareDocumentPosition) {
+ return node1.compareDocumentPosition(node2) & 2 ? 1 : -1
+ }if("sourceIndex" in node1 || node1.parentNode && "sourceIndex" in node1.parentNode) {
+ var isElement1 = node1.nodeType == goog.dom.NodeType.ELEMENT, isElement2 = node2.nodeType == goog.dom.NodeType.ELEMENT, index1 = isElement1 ? node1.sourceIndex : node1.parentNode.sourceIndex, index2 = isElement2 ? node2.sourceIndex : node2.parentNode.sourceIndex;
+ if(index1 != index2) {
+ return index1 - index2
+ }else {
+ if(isElement1) {
+ return-1
+ }if(isElement2) {
+ return 1
+ }var s = node2;
+ while(s = s.previousSibling) {
+ if(s == node1) {
+ return-1
+ }
+ }return 1
+ }
+ }var doc = goog.dom.getOwnerDocument(node1), range1, range2;
+ range1 = doc.createRange();
+ range1.selectNode(node1);
+ range1.collapse(true);
+ range2 = doc.createRange();
+ range2.selectNode(node2);
+ range2.collapse(true);
+ return range1.compareBoundaryPoints(Range.START_TO_END, range2)
+};
+goog.dom.getOwnerDocument = function(node) {
+ return node.nodeType == goog.dom.NodeType.DOCUMENT ? node : node.ownerDocument || node.document
+};
+goog.dom.getFrameContentDocument = function(frame) {
+ return goog.userAgent.SAFARI ? frame.document || frame.contentWindow.document : frame.contentDocument || frame.contentWindow.document
+};
+goog.dom.setTextContent = function(element, text) {
+ if("textContent" in element) {
+ element.textContent = text
+ }else if(element.firstChild && element.firstChild.nodeType == goog.dom.NodeType.TEXT) {
+ while(element.lastChild != element.firstChild) {
+ element.removeChild(element.lastChild)
+ }element.firstChild.data = text
+ }else {
+ while(element.hasChildNodes()) {
+ element.removeChild(element.lastChild)
+ }var doc = goog.dom.getOwnerDocument(element);
+ element.appendChild(doc.createTextNode(text))
+ }
+};
+goog.dom.findNode = function(root, p) {
+ var rv = [];
+ goog.dom.findNodes_(root, p, rv, true);
+ return rv.length ? rv[0] : undefined
+};
+goog.dom.findNodes = function(root, p) {
+ var rv = [];
+ goog.dom.findNodes_(root, p, rv, false);
+ return rv
+};
+goog.dom.findNodes_ = function(root, p, rv, findOne) {
+ if(root != null) {
+ for(var i = 0, child;child = root.childNodes[i];i++) {
+ if(p(child)) {
+ rv.push(child);
+ if(findOne) {
+ return
+ }
+ }goog.dom.findNodes_(child, p, rv, findOne)
+ }
+ }
+};
+goog.dom.TAGS_TO_IGNORE = {SCRIPT:1, STYLE:1, HEAD:1, IFRAME:1, OBJECT:1};
+goog.dom.PREDEFINED_TAG_VALUES = {IMG:" ", BR:"\n"};
+goog.dom.getTextContent = function(node) {
+ if(goog.userAgent.IE && "innerText" in node) {
+ return goog.string.canonicalizeNewlines(node.innerText)
+ }var buf = [];
+ goog.dom.getTextContent_(node, buf, true);
+ var rv = buf.join("").replace(/ +/g, " ");
+ if(rv != " ") {
+ rv = rv.replace(/^\s*/, "")
+ }return rv
+};
+goog.dom.getRawTextContent = function(node) {
+ var buf = [];
+ goog.dom.getTextContent_(node, buf, false);
+ return buf.join("")
+};
+goog.dom.getTextContent_ = function(node, buf, normalizeWhitespace) {
+ if(node.nodeName in goog.dom.TAGS_TO_IGNORE) {
+ }else if(node.nodeType == goog.dom.NodeType.TEXT) {
+ if(normalizeWhitespace) {
+ buf.push(String(node.nodeValue).replace(/(\r\n|\r|\n)/g, ""))
+ }else {
+ buf.push(node.nodeValue)
+ }
+ }else if(node.nodeName in goog.dom.PREDEFINED_TAG_VALUES) {
+ buf.push(goog.dom.PREDEFINED_TAG_VALUES[node.nodeName])
+ }else {
+ var child = node.firstChild;
+ while(child) {
+ goog.dom.getTextContent_(child, buf, normalizeWhitespace);
+ child = child.nextSibling
+ }
+ }
+};
+goog.dom.getNodeTextLength = function(node) {
+ return goog.dom.getTextContent(node).length
+};
+goog.dom.getNodeTextOffset = function(node, opt_offsetParent) {
+ var root = opt_offsetParent || goog.dom.getOwnerDocument(node).body, buf = [];
+ while(node && node != root) {
+ var cur = node;
+ while(cur = cur.previousSibling) {
+ buf.unshift(goog.dom.getTextContent(cur))
+ }node = node.parentNode
+ }return goog.string.trimLeft(buf.join("")).replace(/ +/g, " ").length
+};
+goog.dom.getNodeAtOffset = function(parent, offset, opt_result) {
+ var stack = [parent], pos = 0, cur;
+ while(stack.length > 0 && pos < offset) {
+ cur = stack.pop();
+ if(cur.nodeName in goog.dom.TAGS_TO_IGNORE) {
+ }else if(cur.nodeType == goog.dom.NodeType.TEXT) {
+ var text = cur.nodeValue.replace(/(\r\n|\r|\n)/g, "").replace(/ +/g, " ");
+ pos += text.length
+ }else if(cur.nodeName in goog.dom.PREDEFINED_TAG_VALUES) {
+ pos += goog.dom.PREDEFINED_TAG_VALUES(cur.nodeName).length
+ }else {
+ for(var i = cur.childNodes.length - 1;i >= 0;i--) {
+ stack.push(cur.childNodes[i])
+ }
+ }
+ }if(goog.isObject(opt_result)) {
+ opt_result.remainder = cur ? cur.nodeValue.length + offset - pos - 1 : 0;
+ opt_result.node = cur
+ }return cur
+};
+goog.dom.DomHelper = function(opt_document) {
+ this.document_ = opt_document || goog.global.document || document
+};
+goog.dom.DomHelper.prototype.getDomHelper = goog.dom.getDomHelper;
+goog.dom.DomHelper.prototype.setDocument = function(document) {
+ this.document_ = document
+};
+goog.dom.DomHelper.prototype.getDocument = function() {
+ return this.document_
+};
+goog.dom.DomHelper.prototype.getElement = function(element) {
+ if(goog.isString(element)) {
+ return this.document_.getElementById(element)
+ }else {
+ return element
+ }
+};
+goog.dom.DomHelper.prototype.$ = goog.dom.DomHelper.prototype.getElement;
+goog.dom.DomHelper.prototype.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
+ var tag = opt_tag || "*", parent = opt_el || this.document_, els = parent.getElementsByTagName(tag);
+ if(opt_class) {
+ var rv = [];
+ for(var i = 0, el;el = els[i];i++) {
+ var className = el.className;
+ if(typeof className.split == "function" && goog.array.contains(className.split(" "), opt_class)) {
+ rv.push(el)
+ }
+ }return rv
+ }else {
+ return els
+ }
+};
+goog.dom.DomHelper.prototype.$$ = goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;
+goog.dom.DomHelper.prototype.setProperties = goog.dom.setProperties;
+goog.dom.DomHelper.prototype.getViewportSize = goog.dom.getViewportSize;
+goog.dom.DomHelper.prototype.createDom = function(tagName, opt_attributes) {
+ if(goog.userAgent.IE && opt_attributes && opt_attributes.name) {
+ tagName = "<" + tagName + ' name="' + goog.string.htmlEscape(opt_attributes.name) + '">'
+ }var element = this.createElement(tagName);
+ if(opt_attributes) {
+ goog.dom.setProperties(element, opt_attributes)
+ }if(arguments.length > 2) {
+ function childHandler(child) {
+ if(child) {
+ this.appendChild(element, goog.isString(child) ? this.createTextNode(child) : child)
+ }
+ }
+ for(var i = 2;i < arguments.length;i++) {
+ var arg = arguments[i];
+ if((goog.isArrayLike(arg) || goog.userAgent.SAFARI && typeof arg == "function" && typeof arg.length == "number") && !goog.dom.isNodeLike(arg)) {
+ goog.array.forEach(goog.isArray(arg) ? arg : goog.array.clone(arg), childHandler, this)
+ }else {
+ childHandler.call(this, arg)
+ }
+ }
+ }return element
+};
+goog.dom.DomHelper.prototype.$dom = goog.dom.DomHelper.prototype.createDom;
+goog.dom.DomHelper.prototype.createElement = function(name) {
+ return this.document_.createElement(name)
+};
+goog.dom.DomHelper.prototype.createTextNode = function(content) {
+ return this.document_.createTextNode(content)
+};
+goog.dom.DomHelper.prototype.htmlToDocumentFragment = function(htmlString) {
+ var tempDiv = this.document_.createElement("div");
+ tempDiv.innerHTML = htmlString;
+ if(tempDiv.childNodes.length == 1) {
+ return tempDiv.firstChild
+ }else {
+ var fragment = this.document_.createDocumentFragment();
+ while(tempDiv.firstChild) {
+ fragment.appendChild(tempDiv.firstChild)
+ }return fragment
+ }
+};
+goog.dom.DomHelper.prototype.getCompatMode = function() {
+ if(this.document_.compatMode) {
+ return this.document_.compatMode
+ }if(goog.userAgent.SAFARI) {
+ var el = this.createDom("div", {style:"position:absolute;width:0;height:0;width:1"}), val = el.style.width == "1px" ? "BackCompat" : "CSS1Compat";
+ return this.document_.compatMode = val
+ }return"BackCompat"
+};
+goog.dom.DomHelper.prototype.appendChild = goog.dom.appendChild;
+goog.dom.DomHelper.prototype.removeChildren = goog.dom.removeChildren;
+goog.dom.DomHelper.prototype.insertSiblingBefore = goog.dom.insertSiblingBefore;
+goog.dom.DomHelper.prototype.insertSiblingAfter = goog.dom.insertSiblingAfter;
+goog.dom.DomHelper.prototype.removeNode = goog.dom.removeNode;
+goog.dom.DomHelper.prototype.getFirstElementChild = goog.dom.getFirstElementChild;
+goog.dom.DomHelper.prototype.getLastElementChild = goog.dom.getLastElementChild;
+goog.dom.DomHelper.prototype.getNextElementSibling = goog.dom.getNextElementSibling;
+goog.dom.DomHelper.prototype.getPreviousElementSibling = goog.dom.getPreviousElementSibling;
+goog.dom.DomHelper.prototype.isNodeLike = goog.dom.isNodeLike;
+goog.dom.DomHelper.prototype.contains = goog.dom.contains;
+goog.dom.DomHelper.prototype.getOwnerDocument = goog.dom.getOwnerDocument;
+goog.dom.DomHelper.prototype.getFrameContentDocument = goog.dom.getFrameContentDocument;
+goog.dom.DomHelper.prototype.setTextContent = goog.dom.setTextContent;
+goog.dom.DomHelper.prototype.findNode = goog.dom.findNode;
+goog.dom.DomHelper.prototype.findNodes = goog.dom.findNodes;
+goog.dom.DomHelper.prototype.getTextContent = goog.dom.getTextContent;
+goog.dom.DomHelper.prototype.getNodeTextLength = goog.dom.getNodeTextLength;
+goog.dom.DomHelper.prototype.getNodeTextOffset = goog.dom.getNodeTextOffset;goog.net = {};
+goog.net.EventType = {COMPLETE:"complete", SUCCESS:"success", ERROR:"error", ABORT:"abort", READY:"ready", READY_STATE_CHANGE:"readystatechange", TIMEOUT:"timeout", INCREMENTAL_DATA:"incrementaldata"};goog.net.XmlHttp = function() {
+ return goog.net.XmlHttp.factory_()
+};
+goog.net.XmlHttp.getOptions = function() {
+ return goog.net.XmlHttp.cachedOptions_ || (goog.net.XmlHttp.cachedOptions_ = goog.net.XmlHttp.optionsFactory_())
+};
+goog.net.XmlHttp.factory_ = null;
+goog.net.XmlHttp.optionsFactory_ = null;
+goog.net.XmlHttp.cachedOptions_ = null;
+goog.net.XmlHttp.setFactory = function(factory, optionsFactory) {
+ goog.net.XmlHttp.factory_ = factory;
+ goog.net.XmlHttp.optionsFactory_ = optionsFactory;
+ goog.net.XmlHttp.cachedOptions_ = null
+};
+goog.net.XmlHttp.defaultFactory_ = function() {
+ var progId = goog.net.XmlHttp.getProgId_();
+ if(progId) {
+ return new ActiveXObject(progId)
+ }else {
+ return new XMLHttpRequest
+ }
+};
+goog.net.XmlHttp.defaultOptionsFactory_ = function() {
+ var progId = goog.net.XmlHttp.getProgId_(), options = {};
+ if(progId) {
+ options[goog.net.XmlHttp.OptionType.USE_NULL_FUNCTION] = true;
+ options[goog.net.XmlHttp.OptionType.LOCAL_REQUEST_ERROR] = true
+ }return options
+};
+goog.net.XmlHttp.setFactory(goog.net.XmlHttp.defaultFactory_, goog.net.XmlHttp.defaultOptionsFactory_);
+goog.net.XmlHttp.OptionType = {USE_NULL_FUNCTION:0, LOCAL_REQUEST_ERROR:1};
+goog.net.XmlHttp.ReadyState = {};
+goog.net.XmlHttp.ReadyState.UNINITIALIZED = 0;
+goog.net.XmlHttp.ReadyState.LOADING = 1;
+goog.net.XmlHttp.ReadyState.LOADED = 2;
+goog.net.XmlHttp.ReadyState.INTERACTIVE = 3;
+goog.net.XmlHttp.ReadyState.COMPLETE = 4;
+goog.net.XmlHttp.ieProgId_ = null;
+goog.net.XmlHttp.getProgId_ = function() {
+ if(!goog.net.XmlHttp.ieProgId_ && typeof XMLHttpRequest == "undefined" && typeof ActiveXObject != "undefined") {
+ var ACTIVE_X_IDENTS = ["MSXML2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP"];
+ for(var i = 0;i < ACTIVE_X_IDENTS.length;i++) {
+ var candidate = ACTIVE_X_IDENTS[i];
+ try {
+ new ActiveXObject(candidate);
+ goog.net.XmlHttp.ieProgId_ = candidate;
+ return candidate
+ }catch(e) {
+ }
+ }throw Error("Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed");
+ }return goog.net.XmlHttp.ieProgId_
+};goog.net.ErrorCode = {NO_ERROR:0, ACCESS_DENIED:1, FILE_NOT_FOUND:2, FF_SILENT_ERROR:3, CUSTOM_ERROR:4, EXCEPTION:5, HTTP_ERROR:6, ABORT:7, TIMEOUT:8};
+goog.net.ErrorCode.getDebugMessage = function(errorCode) {
+ switch(errorCode) {
+ case goog.net.ErrorCode.NO_ERROR:
+ return"No Error";
+ case goog.net.ErrorCode.ACCESS_DENIED:
+ return"Access denied to content document";
+ case goog.net.ErrorCode.FILE_NOT_FOUND:
+ return"File not found";
+ case goog.net.ErrorCode.FF_SILENT_ERROR:
+ return"Firefox silently errored";
+ case goog.net.ErrorCode.CUSTOM_ERROR:
+ return"Application custom error";
+ case goog.net.ErrorCode.EXCEPTION:
+ return"An exception occurred";
+ case goog.net.ErrorCode.HTTP_ERROR:
+ return"Http response at 400 or 500 level";
+ case goog.net.ErrorCode.ABORT:
+ return"Request was aborted";
+ case goog.net.ErrorCode.TIMEOUT:
+ return"Request timed out";
+ default:
+ return"Unrecognized error code"
+ }
+};goog.structs = {};
+goog.structs.getCount = function(col) {
+ if(typeof col.getCount == "function") {
+ return col.getCount()
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return col.length
+ }return goog.object.getCount(col)
+};
+goog.structs.getValues = function(col) {
+ if(typeof col.getValues == "function") {
+ return col.getValues()
+ }if(goog.isString(col)) {
+ return col.split("")
+ }if(goog.isArrayLike(col)) {
+ var rv = [], l = col.length;
+ for(var i = 0;i < l;i++) {
+ rv.push(col[i])
+ }return rv
+ }return goog.object.getValues(col)
+};
+goog.structs.getKeys = function(col) {
+ if(typeof col.getKeys == "function") {
+ return col.getKeys()
+ }if(typeof col.getValues == "function") {
+ return undefined
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ var rv = [], l = col.length;
+ for(var i = 0;i < l;i++) {
+ rv.push(i)
+ }return rv
+ }return goog.object.getKeys(col)
+};
+goog.structs.contains = function(col, val) {
+ if(typeof col.contains == "function") {
+ return col.contains(val)
+ }if(typeof col.containsValue == "function") {
+ return col.containsValue(val)
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.contains(col, val)
+ }return goog.object.containsValue(col, val)
+};
+goog.structs.isEmpty = function(col) {
+ if(typeof col.isEmpty == "function") {
+ return col.isEmpty()
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.isEmpty(col)
+ }return goog.object.isEmpty(col)
+};
+goog.structs.clear = function(col) {
+ if(typeof col.clear == "function") {
+ col.clear()
+ }else if(goog.isArrayLike(col)) {
+ goog.array.clear(col)
+ }else {
+ goog.object.clear(col)
+ }
+};
+goog.structs.forEach = function(col, f, opt_obj) {
+ if(typeof col.forEach == "function") {
+ col.forEach(f, opt_obj)
+ }else if(goog.isArrayLike(col) || goog.isString(col)) {
+ goog.array.forEach(col, f, opt_obj)
+ }else {
+ var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
+ for(var i = 0;i < l;i++) {
+ f.call(opt_obj, values[i], keys && keys[i], col)
+ }
+ }
+};
+goog.structs.filter = function(col, f, opt_obj, opt_constr) {
+ if(typeof col.filter == "function") {
+ return col.filter(f, opt_obj)
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.filter(col, f, opt_obj)
+ }var rv, keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
+ if(keys && goog.structs.Map) {
+ rv = new (opt_constr || Object);
+ for(var i = 0;i < l;i++) {
+ if(f.call(opt_obj, values[i], keys[i], col)) {
+ goog.structs.Map.set(rv, keys[i], values[i])
+ }
+ }
+ }else if(goog.structs.Set) {
+ rv = new (opt_constr || Array);
+ for(var i = 0;i < l;i++) {
+ if(f.call(opt_obj, values[i], undefined, col)) {
+ goog.structs.Set.add(rv, values[i])
+ }
+ }
+ }return rv
+};
+goog.structs.map = function(col, f, opt_obj, opt_constr) {
+ if(typeof col.map == "function") {
+ return col.map(f, opt_obj)
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.map(col, f, opt_obj)
+ }var rv, keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
+ if(keys && goog.structs.Map) {
+ rv = new (opt_constr || Object);
+ for(var i = 0;i < l;i++) {
+ goog.structs.Map.set(rv, keys[i], f.call(opt_obj, values[i], keys[i], col))
+ }
+ }else if(goog.structs.Set) {
+ rv = new (opt_constr || Array);
+ for(var i = 0;i < l;i++) {
+ goog.structs.Set.add(rv, f.call(opt_obj, values[i], undefined, col))
+ }
+ }return rv
+};
+goog.structs.some = function(col, f, opt_obj) {
+ if(typeof col.some == "function") {
+ return col.some(f, opt_obj)
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.some(col, f, opt_obj)
+ }var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
+ for(var i = 0;i < l;i++) {
+ if(f.call(opt_obj, values[i], keys && keys[i], col)) {
+ return true
+ }
+ }return false
+};
+goog.structs.every = function(col, f, opt_obj) {
+ if(typeof col.every == "function") {
+ return col.every(f, opt_obj)
+ }if(goog.isArrayLike(col) || goog.isString(col)) {
+ return goog.array.every(col, f, opt_obj)
+ }var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
+ for(var i = 0;i < l;i++) {
+ if(!f.call(opt_obj, values[i], keys && keys[i], col)) {
+ return false
+ }
+ }return true
+};goog.structs.Map = function(opt_map) {
+ this.map_ = {};
+ this.keys_ = [];
+ if(opt_map) {
+ this.addAll(opt_map)
+ }
+};
+goog.structs.Map.keyPrefix_ = ":";
+goog.structs.Map.keyPrefixCharCode_ = goog.structs.Map.keyPrefix_.charCodeAt(0);
+goog.structs.Map.prototype.count_ = 0;
+goog.structs.Map.toInternalKey_ = function(key) {
+ key = String(key);
+ if(key in Object.prototype) {
+ return goog.structs.Map.keyPrefix_ + key
+ }else if(key.charCodeAt(0) == goog.structs.Map.keyPrefixCharCode_) {
+ return goog.structs.Map.keyPrefix_ + key
+ }else {
+ return key
+ }
+};
+goog.structs.Map.fromInternalKey_ = function(internalKey) {
+ if(internalKey.charCodeAt(0) == goog.structs.Map.keyPrefixCharCode_) {
+ return internalKey.substring(1)
+ }else {
+ return internalKey
+ }
+};
+goog.structs.Map.prototype.getCount = function() {
+ return this.count_
+};
+goog.structs.Map.prototype.getValues = function() {
+ this.cleanupKeysArray_();
+ var rv = [];
+ for(var i = 0;i < this.keys_.length;i++) {
+ var key = this.keys_[i];
+ rv.push(this.map_[key])
+ }return rv
+};
+goog.structs.Map.prototype.getKeys = function() {
+ this.cleanupKeysArray_();
+ var rv = [];
+ for(var i = 0;i < this.keys_.length;i++) {
+ var key = this.keys_[i];
+ rv.push(goog.structs.Map.fromInternalKey_(key))
+ }return rv
+};
+goog.structs.Map.prototype.containsKey = function(key) {
+ return goog.structs.Map.toInternalKey_(key) in this.map_
+};
+goog.structs.Map.prototype.containsValue = function(val) {
+ for(var i = 0;i < this.keys_.length;i++) {
+ var key = this.keys_[i];
+ if(key in this.map_) {
+ if(this.map_[key] == val) {
+ return true
+ }
+ }
+ }return false
+};
+goog.structs.Map.prototype.isEmpty = function() {
+ return this.count_ == 0
+};
+goog.structs.Map.prototype.clear = function() {
+ this.map_ = {};
+ this.keys_.length = 0;
+ this.count_ = 0
+};
+goog.structs.Map.prototype.remove = function(key) {
+ var internalKey = goog.structs.Map.toInternalKey_(key);
+ if(goog.object.remove(this.map_, internalKey)) {
+ this.count_--;
+ if(this.keys_.length > 2 * this.count_) {
+ this.cleanupKeysArray_()
+ }return true
+ }return false
+};
+goog.structs.Map.prototype.cleanupKeysArray_ = function() {
+ if(this.count_ != this.keys_.length) {
+ var srcIndex = 0, destIndex = 0;
+ while(srcIndex < this.keys_.length) {
+ var key = this.keys_[srcIndex];
+ if(key in this.map_) {
+ this.keys_[destIndex++] = key
+ }srcIndex++
+ }this.keys_.length = destIndex
+ }if(this.count_ != this.keys_.length) {
+ var seen = {}, srcIndex = 0, destIndex = 0;
+ while(srcIndex < this.keys_.length) {
+ var key = this.keys_[srcIndex];
+ if(!(key in seen)) {
+ this.keys_[destIndex++] = key;
+ seen[key] = 1
+ }srcIndex++
+ }this.keys_.length = destIndex
+ }
+};
+goog.structs.Map.prototype.get = function(key, opt_val) {
+ var internalKey = goog.structs.Map.toInternalKey_(key);
+ if(internalKey in this.map_) {
+ return this.map_[internalKey]
+ }return opt_val
+};
+goog.structs.Map.prototype.set = function(key, value) {
+ var internalKey = goog.structs.Map.toInternalKey_(key);
+ if(!(internalKey in this.map_)) {
+ this.count_++;
+ this.keys_.push(internalKey)
+ }this.map_[internalKey] = value
+};
+goog.structs.Map.prototype.addAll = function(map) {
+ var keys, values;
+ if(map instanceof goog.structs.Map) {
+ keys = map.getKeys();
+ values = map.getValues()
+ }else {
+ keys = goog.object.getKeys(map);
+ values = goog.object.getValues(map)
+ }for(var i = 0;i < keys.length;i++) {
+ this.set(keys[i], values[i])
+ }
+};
+goog.structs.Map.prototype.clone = function() {
+ return new goog.structs.Map(this)
+};
+goog.structs.Map.getCount = function(map) {
+ return goog.structs.getCount(map)
+};
+goog.structs.Map.getValues = function(map) {
+ return goog.structs.getValues(map)
+};
+goog.structs.Map.getKeys = function(map) {
+ if(typeof map.getKeys == goog.JsType_.FUNCTION) {
+ return map.getKeys()
+ }var rv = [];
+ if(goog.isArrayLike(map)) {
+ for(var i = 0;i < map.length;i++) {
+ rv.push(i)
+ }
+ }else {
+ return goog.object.getKeys(map)
+ }return rv
+};
+goog.structs.Map.containsKey = function(map, key) {
+ if(typeof map.containsKey == goog.JsType_.FUNCTION) {
+ return map.containsKey(key)
+ }if(goog.isArrayLike(map)) {
+ return key < map.length
+ }return goog.object.containsKey(map, key)
+};
+goog.structs.Map.containsValue = function(map, val) {
+ return goog.structs.contains(map, val)
+};
+goog.structs.Map.isEmpty = function(map) {
+ return goog.structs.isEmpty(map)
+};
+goog.structs.Map.clear = function(map) {
+ goog.structs.clear(map)
+};
+goog.structs.Map.remove = function(map, key) {
+ if(typeof map.remove == goog.JsType_.FUNCTION) {
+ return map.remove(key)
+ }if(goog.isArrayLike(map)) {
+ return goog.array.removeAt(map, key)
+ }return goog.object.remove(map, key)
+};
+goog.structs.Map.add = function(map, key, val) {
+ if(typeof map.add == goog.JsType_.FUNCTION) {
+ map.add(key, val)
+ }else if(goog.structs.Map.containsKey(map, key)) {
+ throw Error('The collection already contains the key "' + key + '"');
+ }else {
+ goog.object.set(map, key, val)
+ }
+};
+goog.structs.Map.get = function(map, key, opt_val) {
+ if(typeof map.get == goog.JsType_.FUNCTION) {
+ return map.get(key, opt_val)
+ }if(goog.structs.Map.containsKey(map, key)) {
+ return map[key]
+ }return opt_val
+};
+goog.structs.Map.set = function(map, key, val) {
+ if(typeof map.set == goog.JsType_.FUNCTION) {
+ map.set(key, val)
+ }else {
+ map[key] = val
+ }
+};goog.structs.Set = function(opt_set) {
+ this.map_ = new goog.structs.Map;
+ if(opt_set) {
+ this.addAll(opt_set)
+ }
+};
+goog.structs.Set.getKey_ = function(val) {
+ var type = typeof val;
+ if(type == "object") {
+ return"o" + goog.getHashCode(val)
+ }else {
+ return type.substr(0, 1) + val
+ }
+};
+goog.structs.Set.prototype.getCount = function() {
+ return this.map_.getCount()
+};
+goog.structs.Set.prototype.add = function(obj) {
+ this.map_.set(goog.structs.Set.getKey_(obj), obj)
+};
+goog.structs.Set.prototype.addAll = function(set) {
+ var values = goog.structs.Set.getValues(set), l = values.length;
+ for(var i = 0;i < l;i++) {
+ this.add(values[i])
+ }
+};
+goog.structs.Set.prototype.remove = function(obj) {
+ return this.map_.remove(goog.structs.Set.getKey_(obj))
+};
+goog.structs.Set.prototype.clear = function() {
+ this.map_.clear()
+};
+goog.structs.Set.prototype.isEmpty = function() {
+ return this.map_.isEmpty()
+};
+goog.structs.Set.prototype.contains = function(obj) {
+ return this.map_.containsKey(goog.structs.Set.getKey_(obj))
+};
+goog.structs.Set.prototype.getValues = function() {
+ return this.map_.getValues()
+};
+goog.structs.Set.prototype.clone = function() {
+ return new goog.structs.Set(this)
+};
+goog.structs.Set.getCount = function(col) {
+ return goog.structs.getCount(col)
+};
+goog.structs.Set.getValues = function(col) {
+ return goog.structs.getValues(col)
+};
+goog.structs.Set.contains = function(col, val) {
+ return goog.structs.contains(col, val)
+};
+goog.structs.Set.isEmpty = function(col) {
+ return goog.structs.isEmpty(col)
+};
+goog.structs.Set.clear = function(col) {
+ goog.structs.clear(col)
+};
+goog.structs.Set.remove = function(col, val) {
+ if(typeof col.remove == "function") {
+ return col.remove(val)
+ }else if(goog.isArrayLike(col)) {
+ return goog.array.remove(col, val)
+ }else {
+ for(var key in col) {
+ if(col[key] == val) {
+ delete col[key];
+ return true
+ }
+ }return false
+ }
+};
+goog.structs.Set.add = function(col, val) {
+ if(typeof col.add == "function") {
+ col.add(val)
+ }else if(goog.isArrayLike(col)) {
+ col[col.length] = val
+ }else {
+ throw Error('The collection does not know how to add "' + val + '"');
+ }
+};goog.debug = {};
+goog.debug.catchErrors = function(opt_logger, opt_cancel, opt_target) {
[... 3034 lines stripped ...]