| /* |
| Copyright (c) 2007, Yahoo! Inc. All rights reserved. |
| Code licensed under the BSD License: |
| http://developer.yahoo.net/yui/license.txt |
| version: 2.3.1 |
| */ |
| /** |
| * The YAHOO object is the single global object used by YUI Library. It |
| * contains utility function for setting up namespaces, inheritance, and |
| * logging. YAHOO.util, YAHOO.widget, and YAHOO.example are namespaces |
| * created automatically for and used by the library. |
| * @module yahoo |
| * @title YAHOO Global |
| */ |
| |
| /** |
| * YAHOO_config is not included as part of the library. Instead it is an |
| * object that can be defined by the implementer immediately before |
| * including the YUI library. The properties included in this object |
| * will be used to configure global properties needed as soon as the |
| * library begins to load. |
| * @class YAHOO_config |
| * @static |
| */ |
| |
| /** |
| * A reference to a function that will be executed every time a YAHOO module |
| * is loaded. As parameter, this function will receive the version |
| * information for the module. See <a href="YAHOO.env.html#getVersion"> |
| * YAHOO.env.getVersion</a> for the description of the version data structure. |
| * @property listener |
| * @type Function |
| * @static |
| * @default undefined |
| */ |
| |
| /** |
| * Set to true if the library will be dynamically loaded after window.onload. |
| * Defaults to false |
| * @property injecting |
| * @type boolean |
| * @static |
| * @default undefined |
| */ |
| |
| /** |
| * Instructs the yuiloader component to dynamically load yui components and |
| * their dependencies. See the yuiloader documentation for more information |
| * about dynamic loading |
| * @property load |
| * @static |
| * @default undefined |
| * @see yuiloader |
| */ |
| |
| if (typeof YAHOO == "undefined") { |
| /** |
| * The YAHOO global namespace object. If YAHOO is already defined, the |
| * existing YAHOO object will not be overwritten so that defined |
| * namespaces are preserved. |
| * @class YAHOO |
| * @static |
| */ |
| var YAHOO = {}; |
| } |
| |
| /** |
| * Returns the namespace specified and creates it if it doesn't exist |
| * <pre> |
| * YAHOO.namespace("property.package"); |
| * YAHOO.namespace("YAHOO.property.package"); |
| * </pre> |
| * Either of the above would create YAHOO.property, then |
| * YAHOO.property.package |
| * |
| * Be careful when naming packages. Reserved words may work in some browsers |
| * and not others. For instance, the following will fail in Safari: |
| * <pre> |
| * YAHOO.namespace("really.long.nested.namespace"); |
| * </pre> |
| * This fails because "long" is a future reserved word in ECMAScript |
| * |
| * @method namespace |
| * @static |
| * @param {String*} arguments 1-n namespaces to create |
| * @return {Object} A reference to the last namespace object created |
| */ |
| YAHOO.namespace = function() { |
| var a=arguments, o=null, i, j, d; |
| for (i=0; i<a.length; i=i+1) { |
| d=a[i].split("."); |
| o=YAHOO; |
| |
| // YAHOO is implied, so it is ignored if it is included |
| for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; j=j+1) { |
| o[d[j]]=o[d[j]] || {}; |
| o=o[d[j]]; |
| } |
| } |
| |
| return o; |
| }; |
| |
| /** |
| * Uses YAHOO.widget.Logger to output a log message, if the widget is |
| * available. |
| * |
| * @method log |
| * @static |
| * @param {String} msg The message to log. |
| * @param {String} cat The log category for the message. Default |
| * categories are "info", "warn", "error", time". |
| * Custom categories can be used as well. (opt) |
| * @param {String} src The source of the the message (opt) |
| * @return {Boolean} True if the log operation was successful. |
| */ |
| YAHOO.log = function(msg, cat, src) { |
| var l=YAHOO.widget.Logger; |
| if(l && l.log) { |
| return l.log(msg, cat, src); |
| } else { |
| return false; |
| } |
| }; |
| |
| /** |
| * Registers a module with the YAHOO object |
| * @method register |
| * @static |
| * @param {String} name the name of the module (event, slider, etc) |
| * @param {Function} mainClass a reference to class in the module. This |
| * class will be tagged with the version info |
| * so that it will be possible to identify the |
| * version that is in use when multiple versions |
| * have loaded |
| * @param {Object} data metadata object for the module. Currently it |
| * is expected to contain a "version" property |
| * and a "build" property at minimum. |
| */ |
| YAHOO.register = function(name, mainClass, data) { |
| var mods = YAHOO.env.modules; |
| if (!mods[name]) { |
| mods[name] = { versions:[], builds:[] }; |
| } |
| var m=mods[name],v=data.version,b=data.build,ls=YAHOO.env.listeners; |
| m.name = name; |
| m.version = v; |
| m.build = b; |
| m.versions.push(v); |
| m.builds.push(b); |
| m.mainClass = mainClass; |
| // fire the module load listeners |
| for (var i=0;i<ls.length;i=i+1) { |
| ls[i](m); |
| } |
| // label the main class |
| if (mainClass) { |
| mainClass.VERSION = v; |
| mainClass.BUILD = b; |
| } else { |
| YAHOO.log("mainClass is undefined for module " + name, "warn"); |
| } |
| }; |
| |
| /** |
| * YAHOO.env is used to keep track of what is known about the YUI library and |
| * the browsing environment |
| * @class YAHOO.env |
| * @static |
| */ |
| YAHOO.env = YAHOO.env || { |
| |
| /** |
| * Keeps the version info for all YUI modules that have reported themselves |
| * @property modules |
| * @type Object[] |
| */ |
| modules: [], |
| |
| /** |
| * List of functions that should be executed every time a YUI module |
| * reports itself. |
| * @property listeners |
| * @type Function[] |
| */ |
| listeners: [] |
| }; |
| |
| /** |
| * Returns the version data for the specified module: |
| * <dl> |
| * <dt>name:</dt> <dd>The name of the module</dd> |
| * <dt>version:</dt> <dd>The version in use</dd> |
| * <dt>build:</dt> <dd>The build number in use</dd> |
| * <dt>versions:</dt> <dd>All versions that were registered</dd> |
| * <dt>builds:</dt> <dd>All builds that were registered.</dd> |
| * <dt>mainClass:</dt> <dd>An object that was was stamped with the |
| * current version and build. If |
| * mainClass.VERSION != version or mainClass.BUILD != build, |
| * multiple versions of pieces of the library have been |
| * loaded, potentially causing issues.</dd> |
| * </dl> |
| * |
| * @method getVersion |
| * @static |
| * @param {String} name the name of the module (event, slider, etc) |
| * @return {Object} The version info |
| */ |
| YAHOO.env.getVersion = function(name) { |
| return YAHOO.env.modules[name] || null; |
| }; |
| |
| /** |
| * Do not fork for a browser if it can be avoided. Use feature detection when |
| * you can. Use the user agent as a last resort. YAHOO.env.ua stores a version |
| * number for the browser engine, 0 otherwise. This value may or may not map |
| * to the version number of the browser using the engine. The value is |
| * presented as a float so that it can easily be used for boolean evaluation |
| * as well as for looking for a particular range of versions. Because of this, |
| * some of the granularity of the version info may be lost (e.g., Gecko 1.8.0.9 |
| * reports 1.8). |
| * @class YAHOO.env.ua |
| * @static |
| */ |
| YAHOO.env.ua = function() { |
| var o={ |
| |
| /** |
| * Internet Explorer version number or 0. Example: 6 |
| * @property ie |
| * @type float |
| */ |
| ie:0, |
| |
| /** |
| * Opera version number or 0. Example: 9.2 |
| * @property opera |
| * @type float |
| */ |
| opera:0, |
| |
| /** |
| * Gecko engine revision number. Will evaluate to 1 if Gecko |
| * is detected but the revision could not be found. Other browsers |
| * will be 0. Example: 1.8 |
| * <pre> |
| * Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7 |
| * Firefox 1.5.0.9: 1.8.0.9 <-- Reports 1.8 |
| * Firefox 2.0.0.3: 1.8.1.3 <-- Reports 1.8 |
| * Firefox 3 alpha: 1.9a4 <-- Reports 1.9 |
| * </pre> |
| * @property gecko |
| * @type float |
| */ |
| gecko:0, |
| |
| /** |
| * AppleWebKit version. KHTML browsers that are not WebKit browsers |
| * will evaluate to 1, other browsers 0. Example: 418.9.1 |
| * <pre> |
| * Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the |
| * latest available for Mac OSX 10.3. |
| * Safari 2.0.2: 416 <-- hasOwnProperty introduced |
| * Safari 2.0.4: 418 <-- preventDefault fixed |
| * Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run |
| * different versions of webkit |
| * Safari 2.0.4 (419.3): 419 <-- Current Safari release |
| * Webkit 212 nightly: 522+ <-- Safari 3.0 (with native SVG) should |
| * be higher than this |
| * |
| * </pre> |
| * http://developer.apple.com/internet/safari/uamatrix.html |
| * @property webkit |
| * @type float |
| */ |
| webkit:0 |
| }; |
| |
| var ua=navigator.userAgent, m; |
| |
| // Modern KHTML browsers should qualify as Safari X-Grade |
| if ((/KHTML/).test(ua)) { |
| o.webkit=1; |
| } |
| // Modern WebKit browsers are at least X-Grade |
| m=ua.match(/AppleWebKit\/([^\s]*)/); |
| if (m&&m[1]) { |
| o.webkit=parseFloat(m[1]); |
| } |
| |
| if (!o.webkit) { // not webkit |
| // @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr) |
| m=ua.match(/Opera[\s\/]([^\s]*)/); |
| if (m&&m[1]) { |
| o.opera=parseFloat(m[1]); |
| } else { // not opera or webkit |
| m=ua.match(/MSIE\s([^;]*)/); |
| if (m&&m[1]) { |
| o.ie=parseFloat(m[1]); |
| } else { // not opera, webkit, or ie |
| m=ua.match(/Gecko\/([^\s]*)/); |
| if (m) { |
| o.gecko=1; // Gecko detected, look for revision |
| m=ua.match(/rv:([^\s\)]*)/); |
| if (m&&m[1]) { |
| o.gecko=parseFloat(m[1]); |
| } |
| } |
| } |
| } |
| } |
| |
| return o; |
| }(); |
| |
| /* |
| * Initializes the global by creating the default namespaces and applying |
| * any new configuration information that is detected. This is the setup |
| * for env. |
| * @method init |
| * @static |
| * @private |
| */ |
| (function() { |
| YAHOO.namespace("util", "widget", "example"); |
| if ("undefined" !== typeof YAHOO_config) { |
| var l=YAHOO_config.listener,ls=YAHOO.env.listeners,unique=true,i; |
| if (l) { |
| // if YAHOO is loaded multiple times we need to check to see if |
| // this is a new config object. If it is, add the new component |
| // load listener to the stack |
| for (i=0;i<ls.length;i=i+1) { |
| if (ls[i]==l) { |
| unique=false; |
| break; |
| } |
| } |
| if (unique) { |
| ls.push(l); |
| } |
| } |
| } |
| })(); |
| /** |
| * Provides the language utilites and extensions used by the library |
| * @class YAHOO.lang |
| */ |
| YAHOO.lang = { |
| /** |
| * Determines whether or not the provided object is an array. |
| * Testing typeof/instanceof/constructor of arrays across frame |
| * boundaries isn't possible in Safari unless you have a reference |
| * to the other frame to test against its Array prototype. To |
| * handle this case, we test well-known array properties instead. |
| * properties. |
| * @method isArray |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isArray: function(o) { |
| |
| if (o) { |
| var l = YAHOO.lang; |
| return l.isNumber(o.length) && l.isFunction(o.splice) && |
| !l.hasOwnProperty(o.length); |
| } |
| return false; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a boolean |
| * @method isBoolean |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isBoolean: function(o) { |
| return typeof o === 'boolean'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a function |
| * @method isFunction |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isFunction: function(o) { |
| return typeof o === 'function'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is null |
| * @method isNull |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isNull: function(o) { |
| return o === null; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a legal number |
| * @method isNumber |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isNumber: function(o) { |
| return typeof o === 'number' && isFinite(o); |
| }, |
| |
| /** |
| * Determines whether or not the provided object is of type object |
| * or function |
| * @method isObject |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isObject: function(o) { |
| return (o && (typeof o === 'object' || YAHOO.lang.isFunction(o))) || false; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a string |
| * @method isString |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isString: function(o) { |
| return typeof o === 'string'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is undefined |
| * @method isUndefined |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| isUndefined: function(o) { |
| return typeof o === 'undefined'; |
| }, |
| |
| /** |
| * Determines whether or not the property was added |
| * to the object instance. Returns false if the property is not present |
| * in the object, or was inherited from the prototype. |
| * This abstraction is provided to enable hasOwnProperty for Safari 1.3.x. |
| * There is a discrepancy between YAHOO.lang.hasOwnProperty and |
| * Object.prototype.hasOwnProperty when the property is a primitive added to |
| * both the instance AND prototype with the same value: |
| * <pre> |
| * var A = function() {}; |
| * A.prototype.foo = 'foo'; |
| * var a = new A(); |
| * a.foo = 'foo'; |
| * alert(a.hasOwnProperty('foo')); // true |
| * alert(YAHOO.lang.hasOwnProperty(a, 'foo')); // false when using fallback |
| * </pre> |
| * @method hasOwnProperty |
| * @param {any} o The object being testing |
| * @return Boolean |
| */ |
| hasOwnProperty: function(o, prop) { |
| if (Object.prototype.hasOwnProperty) { |
| return o.hasOwnProperty(prop); |
| } |
| |
| return !YAHOO.lang.isUndefined(o[prop]) && |
| o.constructor.prototype[prop] !== o[prop]; |
| }, |
| |
| /** |
| * IE will not enumerate native functions in a derived object even if the |
| * function was overridden. This is a workaround for specific functions |
| * we care about on the Object prototype. |
| * @property _IEEnumFix |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @static |
| * @private |
| */ |
| _IEEnumFix: function(r, s) { |
| if (YAHOO.env.ua.ie) { |
| var add=["toString", "valueOf"], i; |
| for (i=0;i<add.length;i=i+1) { |
| var fname=add[i],f=s[fname]; |
| if (YAHOO.lang.isFunction(f) && f!=Object.prototype[fname]) { |
| r[fname]=f; |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Utility to set up the prototype, constructor and superclass properties to |
| * support an inheritance strategy that can chain constructors and methods. |
| * Static members will not be inherited. |
| * |
| * @method extend |
| * @static |
| * @param {Function} subc the object to modify |
| * @param {Function} superc the object to inherit |
| * @param {Object} overrides additional properties/methods to add to the |
| * subclass prototype. These will override the |
| * matching items obtained from the superclass |
| * if present. |
| */ |
| extend: function(subc, superc, overrides) { |
| if (!superc||!subc) { |
| throw new Error("YAHOO.lang.extend failed, please check that " + |
| "all dependencies are included."); |
| } |
| var F = function() {}; |
| F.prototype=superc.prototype; |
| subc.prototype=new F(); |
| subc.prototype.constructor=subc; |
| subc.superclass=superc.prototype; |
| if (superc.prototype.constructor == Object.prototype.constructor) { |
| superc.prototype.constructor=superc; |
| } |
| |
| if (overrides) { |
| for (var i in overrides) { |
| subc.prototype[i]=overrides[i]; |
| } |
| |
| YAHOO.lang._IEEnumFix(subc.prototype, overrides); |
| } |
| }, |
| |
| /** |
| * Applies all properties in the supplier to the receiver if the |
| * receiver does not have these properties yet. Optionally, one or |
| * more methods/properties can be specified (as additional |
| * parameters). This option will overwrite the property if receiver |
| * has it already. If true is passed as the third parameter, all |
| * properties will be applied and _will_ overwrite properties in |
| * the receiver. |
| * |
| * @method augmentObject |
| * @static |
| * @since 2.3.0 |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {String*|boolean} arguments zero or more properties methods |
| * to augment the receiver with. If none specified, everything |
| * in the supplier will be used unless it would |
| * overwrite an existing property in the receiver. If true |
| * is specified as the third parameter, all properties will |
| * be applied and will overwrite an existing property in |
| * the receiver |
| */ |
| augmentObject: function(r, s) { |
| if (!s||!r) { |
| throw new Error("Absorb failed, verify dependencies."); |
| } |
| var a=arguments, i, p, override=a[2]; |
| if (override && override!==true) { // only absorb the specified properties |
| for (i=2; i<a.length; i=i+1) { |
| r[a[i]] = s[a[i]]; |
| } |
| } else { // take everything, overwriting only if the third parameter is true |
| for (p in s) { |
| if (override || !r[p]) { |
| r[p] = s[p]; |
| } |
| } |
| |
| YAHOO.lang._IEEnumFix(r, s); |
| } |
| }, |
| |
| /** |
| * Same as YAHOO.lang.augmentObject, except it only applies prototype properties |
| * @see YAHOO.lang.augmentObject |
| * @method augmentProto |
| * @static |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {String*|boolean} arguments zero or more properties methods |
| * to augment the receiver with. If none specified, everything |
| * in the supplier will be used unless it would overwrite an existing |
| * property in the receiver. if true is specified as the third |
| * parameter, all properties will be applied and will overwrite an |
| * existing property in the receiver |
| */ |
| augmentProto: function(r, s) { |
| if (!s||!r) { |
| throw new Error("Augment failed, verify dependencies."); |
| } |
| //var a=[].concat(arguments); |
| var a=[r.prototype,s.prototype]; |
| for (var i=2;i<arguments.length;i=i+1) { |
| a.push(arguments[i]); |
| } |
| YAHOO.lang.augmentObject.apply(this, a); |
| }, |
| |
| |
| /** |
| * Returns a simple string representation of the object or array. |
| * Other types of objects will be returned unprocessed. Arrays |
| * are expected to be indexed. Use object notation for |
| * associative arrays. |
| * @method dump |
| * @since 2.3.0 |
| * @param o {Object} The object to dump |
| * @param d {int} How deep to recurse child objects, default 3 |
| * @return {String} the dump result |
| */ |
| dump: function(o, d) { |
| var l=YAHOO.lang,i,len,s=[],OBJ="{...}",FUN="f(){...}", |
| COMMA=', ', ARROW=' => '; |
| |
| // Cast non-objects to string |
| // Skip dates because the std toString is what we want |
| // Skip HTMLElement-like objects because trying to dump |
| // an element will cause an unhandled exception in FF 2.x |
| if (!l.isObject(o)) { |
| return o + ""; |
| } else if (o instanceof Date || ("nodeType" in o && "tagName" in o)) { |
| return o; |
| } else if (l.isFunction(o)) { |
| return FUN; |
| } |
| |
| // dig into child objects the depth specifed. Default 3 |
| d = (l.isNumber(d)) ? d : 3; |
| |
| // arrays [1, 2, 3] |
| if (l.isArray(o)) { |
| s.push("["); |
| for (i=0,len=o.length;i<len;i=i+1) { |
| if (l.isObject(o[i])) { |
| s.push((d > 0) ? l.dump(o[i], d-1) : OBJ); |
| } else { |
| s.push(o[i]); |
| } |
| s.push(COMMA); |
| } |
| if (s.length > 1) { |
| s.pop(); |
| } |
| s.push("]"); |
| // objects {k1 => v1, k2 => v2} |
| } else { |
| s.push("{"); |
| for (i in o) { |
| if (l.hasOwnProperty(o, i)) { |
| s.push(i + ARROW); |
| if (l.isObject(o[i])) { |
| s.push((d > 0) ? l.dump(o[i], d-1) : OBJ); |
| } else { |
| s.push(o[i]); |
| } |
| s.push(COMMA); |
| } |
| } |
| if (s.length > 1) { |
| s.pop(); |
| } |
| s.push("}"); |
| } |
| |
| return s.join(""); |
| }, |
| |
| /** |
| * Does variable substitution on a string. It scans through the string |
| * looking for expressions enclosed in { } braces. If an expression |
| * is found, it is used a key on the object. If there is a space in |
| * the key, the first word is used for the key and the rest is provided |
| * to an optional function to be used to programatically determine the |
| * value (the extra information might be used for this decision). If |
| * the value for the key in the object, or what is returned from the |
| * function has a string value, number value, or object value, it is |
| * substituted for the bracket expression and it repeats. If this |
| * value is an object, it uses the Object's toString() if this has |
| * been overridden, otherwise it does a shallow dump of the key/value |
| * pairs. |
| * @method substitute |
| * @since 2.3.0 |
| * @param s {String} The string that will be modified. |
| * @param o {Object} An object containing the replacement values |
| * @param f {Function} An optional function that can be used to |
| * process each match. It receives the key, |
| * value, and any extra metadata included with |
| * the key inside of the braces. |
| * @return {String} the substituted string |
| */ |
| substitute: function (s, o, f) { |
| var i, j, k, key, v, meta, l=YAHOO.lang, saved=[], token, |
| DUMP='dump', SPACE=' ', LBRACE='{', RBRACE='}'; |
| |
| |
| for (;;) { |
| i = s.lastIndexOf(LBRACE); |
| if (i < 0) { |
| break; |
| } |
| j = s.indexOf(RBRACE, i); |
| if (i + 1 >= j) { |
| break; |
| } |
| |
| //Extract key and meta info |
| token = s.substring(i + 1, j); |
| key = token; |
| meta = null; |
| k = key.indexOf(SPACE); |
| if (k > -1) { |
| meta = key.substring(k + 1); |
| key = key.substring(0, k); |
| } |
| |
| // lookup the value |
| v = o[key]; |
| |
| // if a substitution function was provided, execute it |
| if (f) { |
| v = f(key, v, meta); |
| } |
| |
| if (l.isObject(v)) { |
| if (l.isArray(v)) { |
| v = l.dump(v, parseInt(meta, 10)); |
| } else { |
| meta = meta || ""; |
| |
| // look for the keyword 'dump', if found force obj dump |
| var dump = meta.indexOf(DUMP); |
| if (dump > -1) { |
| meta = meta.substring(4); |
| } |
| |
| // use the toString if it is not the Object toString |
| // and the 'dump' meta info was not found |
| if (v.toString===Object.prototype.toString||dump>-1) { |
| v = l.dump(v, parseInt(meta, 10)); |
| } else { |
| v = v.toString(); |
| } |
| } |
| } else if (!l.isString(v) && !l.isNumber(v)) { |
| // This {block} has no replace string. Save it for later. |
| v = "~-" + saved.length + "-~"; |
| saved[saved.length] = token; |
| |
| // break; |
| } |
| |
| s = s.substring(0, i) + v + s.substring(j + 1); |
| |
| |
| } |
| |
| // restore saved {block}s |
| for (i=saved.length-1; i>=0; i=i-1) { |
| s = s.replace(new RegExp("~-" + i + "-~"), "{" + saved[i] + "}", "g"); |
| } |
| |
| return s; |
| }, |
| |
| |
| /** |
| * Returns a string without any leading or trailing whitespace. If |
| * the input is not a string, the input will be returned untouched. |
| * @method trim |
| * @since 2.3.0 |
| * @param s {string} the string to trim |
| * @return {string} the trimmed string |
| */ |
| trim: function(s){ |
| try { |
| return s.replace(/^\s+|\s+$/g, ""); |
| } catch(e) { |
| return s; |
| } |
| }, |
| |
| /** |
| * Returns a new object containing all of the properties of |
| * all the supplied objects. The properties from later objects |
| * will overwrite those in earlier objects. |
| * @method merge |
| * @since 2.3.0 |
| * @param arguments {Object*} the objects to merge |
| * @return the new merged object |
| */ |
| merge: function() { |
| var o={}, a=arguments, i; |
| for (i=0; i<a.length; i=i+1) { |
| YAHOO.lang.augmentObject(o, a[i], true); |
| /* |
| for (var j in a[i]) { |
| o[j] = a[i][j]; |
| } |
| */ |
| } |
| return o; |
| }, |
| |
| /** |
| * A convenience method for detecting a legitimate non-null value. |
| * Returns false for null/undefined/NaN, true for other values, |
| * including 0/false/'' |
| * @method isValue |
| * @since 2.3.0 |
| * @param o {any} the item to test |
| * @return {boolean} true if it is not null/undefined/NaN || false |
| */ |
| isValue: function(o) { |
| // return (o || o === false || o === 0 || o === ''); // Infinity fails |
| var l = YAHOO.lang; |
| return (l.isObject(o) || l.isString(o) || l.isNumber(o) || l.isBoolean(o)); |
| } |
| |
| }; |
| |
| /* |
| * An alias for <a href="YAHOO.lang.html">YAHOO.lang</a> |
| * @class YAHOO.util.Lang |
| */ |
| YAHOO.util.Lang = YAHOO.lang; |
| |
| /** |
| * Same as YAHOO.lang.augmentObject, except it only applies prototype |
| * properties. This is an alias for augmentProto. |
| * @see YAHOO.lang.augmentObject |
| * @method augment |
| * @static |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {String*|boolean} arguments zero or more properties methods to |
| * augment the receiver with. If none specified, everything |
| * in the supplier will be used unless it would |
| * overwrite an existing property in the receiver. if true |
| * is specified as the third parameter, all properties will |
| * be applied and will overwrite an existing property in |
| * the receiver |
| */ |
| YAHOO.lang.augment = YAHOO.lang.augmentProto; |
| |
| /** |
| * An alias for <a href="YAHOO.lang.html#augment">YAHOO.lang.augment</a> |
| * @for YAHOO |
| * @method augment |
| * @static |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {String*} arguments zero or more properties methods to |
| * augment the receiver with. If none specified, everything |
| * in the supplier will be used unless it would |
| * overwrite an existing property in the receiver |
| */ |
| YAHOO.augment = YAHOO.lang.augmentProto; |
| |
| /** |
| * An alias for <a href="YAHOO.lang.html#extend">YAHOO.lang.extend</a> |
| * @method extend |
| * @static |
| * @param {Function} subc the object to modify |
| * @param {Function} superc the object to inherit |
| * @param {Object} overrides additional properties/methods to add to the |
| * subclass prototype. These will override the |
| * matching items obtained from the superclass if present. |
| */ |
| YAHOO.extend = YAHOO.lang.extend; |
| |
| YAHOO.register("yahoo", YAHOO, {version: "2.3.1", build: "541"}); |
