0001 
0002 /*
0003  *  JScripter Standard 1.0 - To Script In Java
0004  *  Copyright (C) 2008-2011  J.J.Liu<jianjunliu@126.com> <http://www.jscripter.org>
0005  *  
0006  *  This program is free software: you can redistribute it and/or modify
0007  *  it under the terms of the GNU Affero General Public License as published by
0008  *  the Free Software Foundation, either version 3 of the License, or
0009  *  (at your option) any later version.
0010  *  
0011  *  This program is distributed in the hope that it will be useful,
0012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
0013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0014  *  GNU Affero General Public License for more details.
0015  *  
0016  *  You should have received a copy of the GNU Affero General Public License
0017  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
0018  */
0019 
0020 package js;
0021 
0022 import js.core.*;
0023 import js.user.*;
0024 
0025 /**
0026  * <p>An <b>opaque</b> class providing basic utilities with its static methods.</p>
0027  *
0028  * @author <a href="mailto:jianjunliu@126.com">J.J.Liu (Jianjun Liu)</a> at <a href="http://www.jscripter.org" target="_blank">http://www.jscripter.org</a>
0029  * 
0030  * @javascript <b>Opaque</b> types can be resolved but no class objects for them can be 
0031  * generated into the target codes. Re-compilers must exit with error on the operations of 
0032  * accessing that kind of class objects.
0033  */
0034 public abstract class Js extends Function<Void>
0035 {
0036     private Js() {}
0037 
0038     private static Sim s = null;
0039 
0040     /**
0041      * <p>An <b>internal</b> method only called internally in {@link Js#init(Sim)} to 
0042      * initialize JS Simulation and JS developers must follow this rule to ensure the 
0043      * class {@link Sim} and its subclasses invisible to JS re-compilers which start 
0044      * processing at {@link JsApplet#onReady()}.</p>
0045      * @since 1.0
0046      * @javascript Re-compilers must report error on the invocation to an <b>internal</b> method. 
0047      */
0048     public static final synchronized void init(Sim sim) {
0049         s = sim;
0050     }
0051     /**
0052      * <p>An <b>internal</b> method only called internally to destroy the cache of static 
0053      * references.</p>
0054      * @since 1.0
0055      * @javascript Re-compilers must report error on the invocation to an <b>internal</b> method. 
0056      */
0057     static final synchronized void destroy() {
0058         s = null;
0059         Static.destroy();
0060     }
0061     /**
0062      * <p>An <b>internal</b> method only called internally to get JS Simulation instance.</p>
0063      * @since 1.0
0064      * @javascript Re-compilers must report error on the invocation to an <b>internal</b> method. 
0065      */
0066     static final Sim s() {
0067         return s;
0068     }
0069 
0070     /**
0071      * <p>Opaquely tells whether the current running environment is JS Simulation (debug mode) 
0072      * or JavaScript (re-compiled).</p>
0073      * @return <tt>true</tt> if the current program is running with JS Simulation 
0074      * (in debug mode); <tt>false</tt> otherwise.
0075      * @since 1.0
0076      * @javascript Re-compilers must ignore the static invocation of this method and simply 
0077      * replace it with a boolean <tt>false</tt> value.
0078      */
0079     public static final boolean debug() {
0080         return true;
0081     }
0082     /**
0083      * <p>Opaquely gets the JavaScript Global object with the core support only.</p>
0084      * <p>This method exists for the efficiency of small tests.</p>
0085      * @return The JavaScript Global object with the core support only.
0086      * @see #win()
0087      * @see jsx.client.Global
0088      * @since 1.0
0089      * @javascript Re-compilers must ignore the static invocation of this method and simply 
0090      * replace it with the expression: 
0091      * <pre>window</pre>
0092      */
0093     public static final JsGlobal core() {
0094         return s().core();
0095     }
0096     /**
0097      * <p>Opaquely gets the JavaScript Global object with the client-side support.</p>
0098      * @return The JavaScript Global object with the client-side support.
0099      * @see #core()
0100      * @see jsx.client.Client
0101      * @since 1.0
0102      * @javascript Re-compilers must ignore the static invocation of this method and simply 
0103      * replace it with the expression: 
0104      * <pre>window</pre>
0105      */
0106     public static final JsWin win() {
0107         return s().win();
0108     }
0109 
0110     /**
0111      * <p>Displays a simple message in a dialog box, 
0112      * simulating the JavaScript global function of the same name.</p>
0113      * <p>In JavaScript, this method displays the specified <tt>message</tt> to the 
0114      * user in a dialog box. The dialog box contains an OK button the user can click to 
0115      * dismiss it. The dialog box is typically modal, and the call to this function 
0116      * typically blocks until the dialog is dismissed.</p>
0117      * <p>Perhaps the most common use of this method is to display error messages when the 
0118      * user's input to some form element is invalid in some way. The alert dialog box can 
0119      * inform the user of the problem and explain what needs to be corrected to avoid the 
0120      * problem in the future</p>
0121      * <p>The appearance of the dialog box is platform-dependent, but it generally contains 
0122      * graphics that indicate an error, warning, or alert message of some kind. While it can 
0123      * display any desired message, the alert graphics of the dialog box mean that this 
0124      * method is not appropriate for simple informational messages like "Welcome to my blog"</p>
0125      * <p>Note that the <tt>message</tt> displayed in the dialog box is a string of 
0126      * plain text, not formatted HTML. You can use the newline character "\n" in your strings 
0127      * to break your message across multiple lines. You can also do some rudimentary 
0128      * formatting using spaces and can approximate horizontal rules with underscore characters, 
0129      * but the results depend greatly on the font used in the dialog box and thus are 
0130      * system-dependent.</p>
0131      * @param message The plain-text (not HTML) string to display in a dialog box popped up 
0132      * over the current window.
0133      * @see jsx.client.Global#alert(Object)
0134      * @see jsx.client.Client#alert(Object)
0135      * @since 1.0
0136      * @javascript Re-compilers must convert the static invocation of this method directly into 
0137      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0138      * method name, but expanding variable arguments, if any, into comma-separated values. 
0139      */
0140     public static final void alert(Object message) { s().alert(message);}
0141     /**
0142      * <p>Asks a yes-or-no question with a dialog box, 
0143      * simulating the JavaScript global function of the same name.</p>
0144      * <p>In JavaScript, this method displays the specified question in a dialog box. The 
0145      * dialog box contains OK and Cancel buttons that the user can use to answer the 
0146      * question. If the user clicks the OK button, it returns <tt>true</tt>. If the 
0147      * user clicks Cancel, it returns <tt>false</tt>.</p>
0148      * <p>The dialog box that is displayed by the this method is modal. That is, it blocks 
0149      * all user input to the main browser window until the user dismisses the dialog box 
0150      * by clicking on the OK or Cancel buttons. Since this method returns a value depending 
0151      * on the user's response to the dialog box, JavaScript execution pauses in the call to 
0152      * this method, and subsequent statements are not executed until the user responds to 
0153      * the dialog box.</p>
0154      * <p>There is no way to change the labels that appear in the buttons of the dialog box 
0155      * (to make them read Yes and No, for example). Therefore, you should take care to 
0156      * phrase your question or message so that OK and Cancel are suitable responses.</p>
0157      * @param question The plain-text (not HTML) string to be displayed in the dialog box. 
0158      * It should generally express a question you want the user to answer.
0159      * @return <tt>true</tt> if the user clicks the OK button; <tt>false</tt> if 
0160      * the user clicks the Cancel button.
0161      * @see jsx.client.Global#confirm(Object)
0162      * @see jsx.client.Client#confirm(Object)
0163      * @since 1.0
0164      * @javascript Re-compilers must convert the static invocation of this method directly into 
0165      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0166      * method name, but expanding variable arguments, if any, into comma-separated values. 
0167      */
0168     public static final boolean confirm(Object question) { return s().confirm(question);}
0169     /**
0170      * <p>Asks for simple string input with a dialog box, 
0171      * simulating the JavaScript global function of the same name.</p>
0172      * <p>This method displays text input field and OK and Cancel buttons in a dialog box. 
0173      * Platform-dependent graphics in the dialog box help indicate to the user that an 
0174      * input is desired.</p>
0175      * <p>If the user clicks the Cancel button, the method returns <tt>null</tt>. If 
0176      * the user clicks the OK button, it returns the text currently displayed in the 
0177      * input field.</p>
0178      * <p>The dialog box that is displayed by this method is modal. That is, it blocks all 
0179      * user input to the main browser window until the user dismisses the dialog box by 
0180      * clicking on the OK or Cancel buttons. Since this method returns a value depending 
0181      * on the user's response to the dialog box, JavaScript execution pauses in the call 
0182      * to this method, and subsequent statements are not executed until the user responds 
0183      * to the dialog box.</p>
0184      * @param message The plain-text (not HTML) string to be displayed in the dialog box. 
0185      * It should ask the user to enter the information you want.
0186      * @return The string entered by the user, the empty string if the user did not enter 
0187      * a string, or <tt>null</tt> if the user clicked Cancel.
0188      * @see #prompt(Object, Object)
0189      * @see jsx.client.Global#prompt(Object)
0190      * @see jsx.client.Client#prompt(Object)
0191      * @since 1.0
0192      * @javascript Re-compilers must convert the static invocation of this method directly into 
0193      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0194      * method name, but expanding variable arguments, if any, into comma-separated values. 
0195      */
0196     public static final String prompt(Object message) { return s().prompt(message);}
0197     /**
0198      * <p>Asks for simple string input with a dialog box, 
0199      * simulating the JavaScript global function of the same name.</p>
0200      * <p>This method displays the specified message in a dialog box that also contains a 
0201      * text input field and OK and Cancel buttons. Platform-dependent graphics in the 
0202      * dialog box help indicate to the user that an input is desired.</p>
0203      * <p>If the user clicks the Cancel button, the method returns <tt>null</tt>. If 
0204      * the user clicks the OK button, it returns the text currently displayed in the 
0205      * input field.</p>
0206      * <p>The dialog box that is displayed by this method is modal. That is, it blocks all 
0207      * user input to the main browser window until the user dismisses the dialog box by 
0208      * clicking on the OK or Cancel buttons. Since this method returns a value depending 
0209      * on the user's response to the dialog box, JavaScript execution pauses in the call 
0210      * to this method, and subsequent statements are not executed until the user responds 
0211      * to the dialog box.</p>
0212      * @param message The plain-text (not HTML) string to be displayed in the dialog box. 
0213      * It should ask the user to enter the information you want.
0214      * @param defaultInput A string that is displayed as the default input in the dialog 
0215      * box. Pass the empty string ("") to make the method display an empty input box.
0216      * @return The string entered by the user, the empty string if the user did not enter 
0217      * a string, or <tt>null</tt> if the user clicked Cancel.
0218      * @see #prompt(Object)
0219      * @see jsx.client.Global#prompt(Object, Object)
0220      * @see jsx.client.Client#prompt(Object, Object)
0221      * @since 1.0
0222      * @javascript Re-compilers must convert the static invocation of this method directly into 
0223      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0224      * method name, but expanding variable arguments, if any, into comma-separated values. 
0225      */
0226     public static final String prompt(Object message, Object defaultInput) { return s().prompt(message, defaultInput);}
0227     /**
0228      * <p>Cancels periodic execution of code, 
0229      * simulating the JavaScript global function of the same name.</p>
0230      * <p>This method stops the repeated execution of code that was started by a call to 
0231      * {@link #setInterval(JsFunction, Number)}. <tt>intervalId</tt> must be the value 
0232      * that was returned by a call to {@link #setInterval(JsFunction, Number)}.</p>
0233      * @param intervalId The value returned by the corresponding call to {@link #setInterval(JsFunction, Number)}.
0234      * @see #setInterval(JsFunction, Number)
0235      * @see jsx.client.Global#clearInterval(Object)
0236      * @see jsx.client.Client#clearInterval(Object)
0237      * @see jsx.Interval
0238      * @since 1.0
0239      * @javascript Re-compilers must convert the static invocation of this method directly into 
0240      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0241      * method name, but expanding variable arguments, if any, into comma-separated values. 
0242      */
0243     public static final void clearInterval(Object intervalId) { s().clearInterval(intervalId);}
0244     /**
0245      * <p>Cancels a pending timeout operation, 
0246      * simulating the JavaScript global function of the same name.</p>
0247      * <p>This method cancels the execution of code that has been deferred with the 
0248      * {@link #setTimeout(JsFunction, Number)} method. The <tt>timeoutId</tt> argument 
0249      * is a value returned by the call to {@link #setTimeout(JsFunction, Number)} and 
0250      * identifies which deferred code to cancel.</p>
0251      * @param timeoutId A value returned by {@link #setTimeout(JsFunction, Number)} that 
0252      * identifies the timeout to be canceled.
0253      * @see #setTimeout(JsFunction)
0254      * @see #setTimeout(JsFunction, Number)
0255      * @see jsx.client.Global#clearTimeout(Object)
0256      * @see jsx.client.Client#clearTimeout(Object)
0257      * @see jsx.Timeout
0258      * @since 1.0
0259      * @javascript Re-compilers must convert the static invocation of this method directly into 
0260      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0261      * method name, but expanding variable arguments, if any, into comma-separated values. 
0262      */
0263     public static final void clearTimeout (Object timeoutId ) { s().clearTimeout (timeoutId);}
0264     /**
0265      * <p>Executes code at periodic intervals, 
0266      * simulating the JavaScript global function of the same name.</p>
0267      * <p>Note that the specified function is executed in the context of the Window object, 
0268      * that is, the Window object is the value of the <tt>this</tt> keyword of the 
0269      * executing context of the function. This is <tt>true</tt> even if the call to 
0270      * {@link #setTimeout(JsFunction, Number)} occurred within a function with a longer 
0271      * scope chain.</p>
0272      * @param f A function to be periodically invoked.
0273      * @param interval The interval, in milliseconds, between invocations of the function.
0274      * @return A value that can be passed to {@link #clearInterval(Object)} method to 
0275      * cancel the periodic execution of the function.
0276      * @see #setInterval(JsFunction)
0277      * @see #clearInterval(Object)
0278      * @see jsx.client.Global#setInterval(JsFunction)
0279      * @see jsx.client.Global#setInterval(JsFunction, Number)
0280      * @see jsx.client.Client#setInterval(JsFunction)
0281      * @see jsx.client.Client#setInterval(JsFunction, Number)
0282      * @see jsx.Interval
0283      * @since 1.0
0284      * @javascript Re-compilers must convert the static invocation of this method directly into 
0285      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0286      * method name, but expanding variable arguments, if any, into comma-separated values. 
0287      */
0288     public static final Object setInterval(JsFunction<?> f, Number interval) { return s().setInterval(f, interval);}
0289     /**
0290      * <p>Executes code at periodic intervals, 
0291      * simulating the JavaScript global function of the same name.</p>
0292      * <p>Note that the specified function is executed in the context of the Window object, 
0293      * that is, the Window object is the value of the <tt>this</tt> keyword of the 
0294      * executing context of the function. This is <tt>true</tt> even if the call to 
0295      * {@link #setTimeout(JsFunction, Number)} occurred within a function with a longer 
0296      * scope chain.</p>
0297      * @param f A function to be periodically invoked.
0298      * @return A value that can be passed to {@link #clearInterval(Object)} method to 
0299      * cancel the periodic execution of the function.
0300      * @see #setInterval(JsFunction, Number)
0301      * @see #clearInterval(Object)
0302      * @see jsx.client.Global#setInterval(JsFunction)
0303      * @see jsx.client.Global#setInterval(JsFunction, Number)
0304      * @see jsx.client.Client#setInterval(JsFunction)
0305      * @see jsx.client.Client#setInterval(JsFunction, Number)
0306      * @see jsx.Interval
0307      * @since 1.0
0308      * @javascript Re-compilers must replace the static invocation of this method with the 
0309      * JavaScript invocation:
0310      * <pre>setInterval(f, 10)</pre>
0311      */
0312     public static final Object setInterval(JsFunction<?> f) { return s().setInterval(f, null);}
0313     /**
0314      * <p>Executes code after a specified amount of time elapses, 
0315      * simulating the JavaScript global function of the same name.</p>
0316      * <p>Note that this method executes the specified function only once. The function is 
0317      * executed in the context of the Window object, that is, the Window object is the 
0318      * value of the <tt>this</tt> keyword of the executing context of the function. 
0319      * This is <tt>true</tt> even if the call to {@link #setTimeout(JsFunction, Number)} 
0320      * occurred within a function with a longer scope chain.</p>
0321      * @param f A function to be invoked after the <tt>delay</tt> has elapsed.
0322      * @param delay The amount of time, in milliseconds, before the function should be executed.
0323      * @return A value that can be passed to the {@link #clearTimeout(Object)} method to 
0324      * cancel the execution of the function.
0325      * @see #setTimeout(JsFunction)
0326      * @see #clearTimeout(Object)
0327      * @see jsx.client.Global#setTimeout(JsFunction)
0328      * @see jsx.client.Global#setTimeout(JsFunction, Number)
0329      * @see jsx.client.Client#setTimeout(JsFunction)
0330      * @see jsx.client.Client#setTimeout(JsFunction, Number)
0331      * @see jsx.Timeout
0332      * @since 1.0
0333      * @javascript Re-compilers must convert the static invocation of this method directly into 
0334      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0335      * method name, but expanding variable arguments, if any, into comma-separated values. 
0336      */
0337     public static final Object setTimeout (JsFunction<?> f, Number delay) { return s().setTimeout (f, delay);}
0338     /**
0339      * <p>Executes code after an amount of time elapses, 
0340      * simulating the JavaScript global function of the same name.</p>
0341      * <p>Note that this method executes the specified function only once. The function is 
0342      * executed in the context of the Window object, that is, the Window object is the 
0343      * value of the <tt>this</tt> keyword of the executing context of the function. 
0344      * This is <tt>true</tt> even if the call to {@link #setTimeout(JsFunction, Number)} 
0345      * occurred within a function with a longer scope chain.</p>
0346      * @param f A function to be invoked after the <tt>delay</tt> has elapsed.
0347      * @return A value that can be passed to the {@link #clearTimeout(Object)} method to 
0348      * cancel the execution of the function.
0349      * @see #setTimeout(JsFunction, Number)
0350      * @see #clearTimeout(Object)
0351      * @see jsx.client.Global#setTimeout(JsFunction)
0352      * @see jsx.client.Global#setTimeout(JsFunction, Number)
0353      * @see jsx.client.Client#setTimeout(JsFunction)
0354      * @see jsx.client.Client#setTimeout(JsFunction, Number)
0355      * @see jsx.Timeout
0356      * @since 1.0
0357      * @javascript Re-compilers must replace the static invocation of this method with the 
0358      * JavaScript invocation:
0359      * <pre>setTimeout(f, 10)</pre>
0360      */
0361     public static final Object setTimeout (JsFunction<?> f) { return s().setTimeout (f, null);}
0362     /**
0363      * <p>Decodes a string escaped with {@link #encodeURI(Object)}, 
0364      * simulating the JavaScript global function of the same name.</p>
0365      * @param s A string that contains an encoded URI or other text to be decoded.
0366      * @return A copy of <tt>s</tt>, with any hexadecimal escape sequences replaced with 
0367      * the characters they represent.
0368      * @throws RuntimeException JavaScript throws a <tt>URIError</tt> if one or more of the 
0369      * escape sequences in <tt>s</tt> is malformed and cannot be correctly decoded. See 
0370      * {@link Js#err(Object)} and {@link js.core.JsURIError} for JS Simulation.
0371      * @see #encodeURI(Object)
0372      * @see jsx.client.Global#decodeURI(Object)
0373      * @see jsx.client.Client#decodeURI(Object)
0374      * @since 1.0
0375      * @javascript Re-compilers must convert the static invocation of this method directly into 
0376      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0377      * method name, but expanding variable arguments, if any, into comma-separated values. 
0378      */
0379     public static final String decodeURI(Object s) { return s().decodeURI(s); }
0380     /**
0381      * <p>Decodes a string escaped with {@link #encodeURIComponent(Object)}, 
0382      * simulating the JavaScript global function of the same name.</p>
0383      * @param s A string that contains an encoded URI component or other text to be decoded.
0384      * @return A copy of <tt>s</tt>, with any hexadecimal escape sequences replaced 
0385      * with the characters they represent.
0386      * @throws RuntimeException JavaScript throws a <tt>URIError</tt> if one or more of the 
0387      * escape sequences in <tt>s</tt> is malformed and cannot be correctly decoded. See 
0388      * {@link Js#err(Object)} and {@link js.core.JsURIError} for JS Simulation.
0389      * @see #encodeURIComponent(Object)
0390      * @see jsx.client.Global#decodeURIComponent(Object)
0391      * @see jsx.client.Client#decodeURIComponent(Object)
0392      * @since 1.0
0393      * @javascript Re-compilers must convert the static invocation of this method directly into 
0394      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0395      * method name, but expanding variable arguments, if any, into comma-separated values. 
0396      */
0397     public static final String decodeURIComponent(Object s) { return s().decodeURIComponent(s); }
0398     /**
0399      * <p>Encodes a URI by escaping certain characters, 
0400      * simulating the JavaScript global function of the same name.</p>
0401      * @param uri A string that contains the URI or other text to be encoded.
0402      * @return A copy of <tt>uri</tt>, with any hexadecimal escape sequences replaced 
0403      * with the characters they represent..
0404      * @throws RuntimeException JavaScript throws a <tt>URIError</tt> if <tt>s</tt> 
0405      * contains malformed unicode surrogate pairs and cannot be encoded. See 
0406      * {@link Js#err(Object)} and {@link js.core.JsURIError} for JS Simulation.
0407      * @see #decodeURI(Object)
0408      * @see jsx.client.Global#encodeURI(Object)
0409      * @see jsx.client.Client#encodeURI(Object)
0410      * @since 1.0
0411      * @javascript Re-compilers must convert the static invocation of this method directly into 
0412      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0413      * method name, but expanding variable arguments, if any, into comma-separated values. 
0414      */
0415     public static final String encodeURI(Object uri) { return s().encodeURI(uri); }
0416     /**
0417      * <p>Encodes a URI component by escaping certain characters, 
0418      * simulating the JavaScript global function of the same name.</p>
0419      * @param uri A string that contains a portion of a URI or other text to be encoded.
0420      * @return A copy of <tt>uri</tt>, with certain characters replaced by hexadecimal escape sequences.
0421      * @throws RuntimeException JavaScript throws a <tt>URIError</tt> if <tt>s</tt> 
0422      * contains malformed unicode surrogate pairs and cannot be encoded. See 
0423      * {@link Js#err(Object)} and {@link js.core.JsURIError} for JS Simulation.
0424      * @see #decodeURIComponent(Object)
0425      * @see jsx.client.Global#encodeURIComponent(Object)
0426      * @see jsx.client.Client#encodeURIComponent(Object)
0427      * @since 1.0
0428      * @javascript Re-compilers must convert the static invocation of this method directly into 
0429      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0430      * method name, but expanding variable arguments, if any, into comma-separated values. 
0431      */
0432     public static final String encodeURIComponent(Object uri) { return s().encodeURIComponent(uri); }
0433     /**
0434      * <p>Encodes a string by replacing certain characters with escape sequences, 
0435      * simulating the JavaScript global function of the same name.</p>
0436      * @param s The string that is to be "escaped" or encoded.
0437      * @return An encoded copy of <tt>s</tt> in which certain characters have been 
0438      * replaced by hexadecimal escape sequences.
0439      * @see #unescape(Object)
0440      * @see jsx.client.Global#escape(Object)
0441      * @see jsx.client.Client#escape(Object)
0442      * @since 1.0
0443      * @javascript Re-compilers must convert the static invocation of this method directly into 
0444      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0445      * method name, but expanding variable arguments, if any, into comma-separated values. 
0446      */
0447     public static final String escape(Object s) { return s().escape(s); }
0448     /**
0449      * <p>Decodes a string encoded with {@link #escape(Object)}, 
0450      * simulating the JavaScript global function of the same name.</p>
0451      * @param s The string that is to be decoded or "unescaped".
0452      * @return A decoded copy of <tt>s</tt>.
0453      * @see #escape(Object)
0454      * @see jsx.client.Global#unescape(Object)
0455      * @see jsx.client.Client#unescape(Object)
0456      * @since 1.0
0457      * @javascript Re-compilers must convert the static invocation of this method directly into 
0458      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0459      * method name, but expanding variable arguments, if any, into comma-separated values. 
0460      */
0461     public static final String unescape(Object s) { return s().escape(s); }
0462     /**
0463      * <p>Evaluates the argument string as JavaScript code and returns the result, 
0464      * simulating the JavaScript global function of the same name.</p>
0465      * <p>In JavaScript, <tt>eval()</tt> is a global method that evaluates a string of 
0466      * JavaScript code in the current lexical scope. If the code contains an expression, 
0467      * eval evaluates the expression and returns its value. If the code contains a 
0468      * JavaScript statement or statements, it executes those statements and returns the 
0469      * value, if any, returned by the last statement. If the code does not return any 
0470      * value, <tt>eval()</tt> returns undefined. Finally, if code throws an exception, 
0471      * <tt>eval()</tt> passes that exception on to the caller.</p>
0472      * <p>The global function <tt>eval()</tt> provides a very powerful capability to 
0473      * the JavaScript language, but its use is infrequent in real-world programs. 
0474      * Obvious uses are to write programs that act as recursive JavaScript interpreters 
0475      * and to write programs that dynamically generate and evaluate JavaScript code.</p>
0476      * <p>Most JavaScript functions and methods that expect string arguments accept 
0477      * arguments of other types as well and simply convert those argument values to 
0478      * strings before proceeding. <tt>eval()</tt> does not behave like this. If the 
0479      * code argument is not a primitive string, it is simply returned unchanged. Be 
0480      * careful, therefore, that you do not inadvertently pass a String object to 
0481      * <tt>eval()</tt> when you intended to pass a primitive string value.</p>
0482      * <p>For purposes of implementation efficiency, the ECMAScript v3 standard places 
0483      * an unusual restriction on the use of <tt>eval()</tt>. An ECMAScript implementation 
0484      * is allowed to throw an <tt>EvalError</tt> exception if you attempt to overwrite 
0485      * the <tt>eval</tt> property or if you assign the <tt>eval()</tt> method to another 
0486      * property and attempt to invoke it through that property.</p>
0487      * @param s A string of JavaScript code.
0488      * @return The return value of the evaluated code, if any.
0489      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> if the argument string 
0490      * does not contain legal JavaScript, a <tt>EvalError</tt> if the <tt>eval</tt> function 
0491      * was called illegally, through an identifier other than "eval", or other JavaScript error 
0492      * generated by the code passed. See {@link Js#err(Object)}, {@link js.core.JsSyntaxError}, 
0493      * {@link js.core.JsEvalError}, and {@link js.core.JsError} for JS Simulation.
0494      * @since 1.0
0495      * @javascript Re-compilers must convert the instance invocation of this method directly into 
0496      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0497      * method name, but expanding variable arguments, if any, into comma-separated values. 
0498      */
0499     public static final Object eval(Object s) {
0500         return s().eval(s);
0501     }
0502     /**
0503      * <p>Tests whether a value is a finite number, 
0504      * simulating the JavaScript global function of the same name.</p>
0505      * @param v The number to be tested.
0506      * @return <tt>true</tt> if <tt>v</tt> is (or can be converted to) a finite 
0507      * number, or <tt>false</tt> if <tt>v</tt> is <tt>NaN</tt> (not a number) 
0508      * or positive or negative infinity.
0509      * @see jsx.client.Global#isFinite(Object)
0510      * @see jsx.client.Client#isFinite(Object)
0511      * @since 1.0
0512      * @javascript Re-compilers must convert the static invocation of this method directly into 
0513      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0514      * method name, but expanding variable arguments, if any, into comma-separated values. 
0515      */
0516     public static final boolean isFinite(Object v) { return s().isFinite(v); }
0517     /**
0518      * <p>Tests whether a value is the not-a-number value, 
0519      * simulating the JavaScript global function of the same name.</p>
0520      * <p>In JavaScript, This function tests its argument to determine whether it is the 
0521      * value <tt>NaN</tt>, which represents an illegal number (such as the result of 
0522      * division by zero). This function is required because comparing a <tt>NaN</tt> 
0523      * with any value, including itself, always returns <tt>false</tt>, so it is not 
0524      * possible to test for <tt>NaN</tt> with the == or === operators.</p>
0525      * <p>A common use in JavaScript of this function is to test the results of {@link #parseFloat(Object)} 
0526      * and {@link #parseInt(Object)} to determine if they represent legal numbers. You can 
0527      * also use {@link #isNaN(Object)} to check for arithmetic errors, such as division by 
0528      * zero</p>
0529      * @param v The value to be tested.
0530      * @return <tt>true</tt> if <tt>v</tt> is (or can be converted to) the special 
0531      * not-a-number value; <tt>false</tt> if <tt>v</tt> is any other value.
0532      * @see jsx.client.Global#isNaN(Object)
0533      * @see jsx.client.Client#isNaN(Object)
0534      * @since 1.0
0535      * @javascript Re-compilers must convert the static invocation of this method directly into 
0536      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0537      * method name, but expanding variable arguments, if any, into comma-separated values. 
0538      */
0539     public static final boolean isNaN(Object v) { return s().isNaN(v); }
0540     /**
0541      * <p>Parses an integer from a string, 
0542      * simulating the JavaScript global function of the same name.</p>
0543      * <p>In JavaScript, this function parses and returns the first number (with an 
0544      * optional leading minus sign) that occurs in <tt>value</tt>. Parsing stops, and 
0545      * the value is returned, when it encounters a character in <tt>value</tt> that is 
0546      * not a valid digit for the specified radix. If <tt>value</tt> does not begin with 
0547      * a number that it can parse, the function returns the not-a-number value <tt>NaN</tt>. 
0548      * Use the {@link #isNaN(Object)} function to test for this return value.</p>
0549      * @param value The string to be parsed.
0550      * @return The parsed number, or <tt>NaN</tt> if <tt>value</tt> does not begin with 
0551      * a valid integer. In JavaScript 1.0, this function returns 0 instead of <tt>NaN</tt> 
0552      * when it cannot parse <tt>value</tt>.
0553      * @see #parseFloat(Object)
0554      * @see #parseInt(Object, int)
0555      * @see jsx.client.Global#parseInt(Object)
0556      * @see jsx.client.Client#parseInt(Object)
0557      * @since 1.0
0558      * @javascript Re-compilers must convert the static invocation of this method directly into 
0559      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0560      * method name, but expanding variable arguments, if any, into comma-separated values. 
0561      */
0562     public static final Integer parseInt(Object value) { return s().parseInt(value); }
0563     /**
0564      * <p>Parses an integer from a string in a base specified, 
0565      * simulating the JavaScript global function of the same name.</p>
0566      * <p>In JavaScript, this function parses and returns the first number (with an 
0567      * optional leading minus sign) that occurs in <tt>value</tt>. Parsing stops, and 
0568      * the value is returned, when it encounters a character in <tt>value</tt> that is 
0569      * not a valid digit for the specified radix. If <tt>value</tt> does not begin with 
0570      * a number that it can parse, the function returns the not-a-number value <tt>NaN</tt>. 
0571      * Use the {@link #isNaN(Object)} function to test for this return value.</p>
0572      * <p>The <tt>radix</tt> argument specifies the base of the number to be parsed. 
0573      * Specifying 10 makes this function parse a decimal number. The value 8 specifies that 
0574      * an octal number (using digits 0 through 7) is to be parsed. The value 16 specifies 
0575      * a hexadecimal value, using digits 0 through 9 and letters A through F. <tt>radix</tt> 
0576      * can be any value between 2 and 36.</p>
0577      * <p>If <tt>radix</tt> is 0 or is undefined, this function tries to determine the 
0578      * radix of the number from <tt>value</tt>. If <tt>value</tt> begins (after an 
0579      * optional minus sign) with 0x, it parses the remainder of <tt>value</tt> as a 
0580      * hexadecimal number. If <tt>value</tt> begins with a 0, the ECMAScript v3 standard 
0581      * allows an implementation of this function to interpret the following characters as 
0582      * an octal number or as a decimal number. Otherwise, if <tt>value</tt> begins with 
0583      * a digit from 1 through 9, it parses it as a decimal number</p>
0584      * @param value The string to be parsed.
0585      * @param radix An optional integer argument that represents the radix (or base) of the 
0586      * number to be parsed. If this argument is undefined or is 0, the number is parsed in 
0587      * base 10 or in base 16 if it begins with 0x or 0X. If this argument is less than 2 or 
0588      * greater than 36, <tt>NaN</tt> is returned.
0589      * @return The parsed number, or <tt>NaN</tt> if <tt>value</tt> does not begin with 
0590      * a valid integer. In JavaScript 1.0, this function returns 0 instead of <tt>NaN</tt> 
0591      * when it cannot parse <tt>value</tt>.
0592      * @see #parseInt(Object)
0593      * @see jsx.client.Global#parseInt(Object, int)
0594      * @see jsx.client.Client#parseInt(Object, int)
0595      * @since 1.0
0596      * @javascript Re-compilers must convert the static invocation of this method directly into 
0597      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0598      * method name, but expanding variable arguments, if any, into comma-separated values. 
0599      */
0600     public static final Integer parseInt(Object value, int radix) { return s().parseInt(value, radix); }
0601     /**
0602      * <p>Parses a number from a string, 
0603      * simulating the JavaScript global function of the same name.</p>
0604      * <p>In JavaScript, this function parses and returns the first number that occurs in 
0605      * <tt>value</tt>. Parsing stops, and the value is returned, when it encounters a 
0606      * character in <tt>value</tt> that is not a valid part of the number. If <tt>value</tt> 
0607      * does not begin with a number that it can parse, the function returns the not-a-number 
0608      * value <tt>NaN</tt>. Test for this return value with the {@link #isNaN(Object)} 
0609      * function. If you want to parse only the integer portion of a number, use {@link #parseInt(Object)} 
0610      * or {@link #parseInt(Object, int)} instead of this one.</p>
0611      * @param value The string to be parsed and converted to a number.
0612      * @return The parsed number, or <tt>NaN</tt> if <tt>value</tt> does not begin 
0613      * with a valid number. In JavaScript 1.0, this function returns 0 instead of <tt>NaN</tt> 
0614      * when <tt>value</tt> cannot be parsed as a number.
0615      * @see #parseInt(Object)
0616      * @see jsx.client.Global#parseFloat(Object)
0617      * @see jsx.client.Client#parseFloat(Object)
0618      * @since 1.0
0619      * @javascript Re-compilers must convert the static invocation of this method directly into 
0620      * a JavaScript invocation on the default object (<tt>window</tt>) without changing the 
0621      * method name, but expanding variable arguments, if any, into comma-separated values. 
0622      */
0623     public static final Double parseFloat(Object value) { return s().parseFloat(value); }
0624 
0625     /**
0626      * <p>Creates and return a <tt>Cases</tt> cache.</p>
0627      * @return The newly created <tt>Cases</tt> cache.
0628      * @since 1.0
0629      * @javascript Re-compilers must, on the static invocation of this method, create a new 
0630      * re-compile time <tt>Cases</tt> cache, without generating any JavaScript statement 
0631      * in the target codes. 
0632      */
0633     public static final Cases cases() { return s().cases();};
0634     /**
0635      * <p>Gets the list of the property names of an object.</p>
0636      * @param o The object.
0637      * @return The list of the property names of the object.
0638      * @since 1.0
0639      * @javascript Re-compilers must replace the static invocation of this method with the 
0640      * JavaScript invocation:
0641      * <pre>keys(o)</pre>
0642      * of a common JavaScript function like:
0643      * <pre>function keys(o) {
0644      *  var keys = [];
0645      *  for (k in o) {
0646      *    keys.put(k);
0647      *  }
0648      *  return keys;
0649      *}</pre>
0650      */
0651     public static final ArrayLike<String> keys(ObjectLike o) { return s().keys(o);}
0652     /**
0653      * <p>Copies all the properties of <tt>a</tt> to <tt>o</tt>.</p>
0654      * @param o The object that the properties being copied to.
0655      * @param a The object that the properties being copied from.
0656      * @since 1.0
0657      * @javascript Re-compilers must replace this static invocation of this method with the 
0658      * JavaScript invocation:
0659      * <pre>copy(o, a)</pre>
0660      * of a common JavaScript function like:
0661      * <pre>function copy(o, a) {
0662      *  for (k in o) {
0663      *    o[k] = a[k];
0664      *  }
0665      *  return o;
0666      *}</pre>
0667      */
0668     public static final ObjectLike apply(ObjectLike o, ObjectLike a) { s().apply(o, a); return o;}
0669 
0670     /**
0671      * <p>Creates an empty JavaScript function.</p>
0672      * <p>A function is a fundamental data-type in JavaScript. Note that although functions 
0673      * may be created with this method, this is not efficient, and the preferred way to 
0674      * define functions, in most cases, is to extend {@link Function}.</p>
0675      * @return A newly created empty function. 
0676      * @see #function(String)
0677      * @see #function(String, String)
0678      * @see #function(Vars, String)
0679      * @see Function
0680      * @see js.core.JsGlobal.Function#create()
0681      * @since 1.0
0682      * @javascript Re-compilers must replace the static invocation of this method with the 
0683      * JavaScript invocation:
0684      * <pre>new Function()</pre>
0685      */
0686     public static final <T> JsFunction<T> function() { return s().function(new Vars<String>());}
0687     /**
0688      * <p>Creates a JavaScript function that has no argument names.</p>
0689      * <p>A function is a fundamental data-type in JavaScript. Note that although functions 
0690      * may be created with this method, this is not efficient, and the preferred way to 
0691      * define functions, in most cases, is to extend {@link Function}.</p>
0692      * @param body A string that specifies the body of the function.
0693      * @return A newly created function. Invoking it executes the JavaScript code specified 
0694      * by <tt>body</tt>.
0695      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> if there was a 
0696      * JavaScript syntax error in one of the value of <tt>body</tt>. See {@link Js#err(Object)} 
0697      * and {@link js.core.JsSyntaxError} for JS Simulation.
0698      * @see #function()
0699      * @see #function(String)
0700      * @see #function(String, String)
0701      * @see Function
0702      * @see js.core.JsGlobal.Function#create(String)
0703      * @see js.core.JsGlobal.Function#create(Vars, String)
0704      * @since 1.0
0705      * @javascript Re-compilers must replace the static invocation of this method with the 
0706      * JavaScript invocation:
0707      * <pre>new Function(body)</pre>
0708      */
0709     public static final <T> JsFunction<T> function(String body) { return s().function(new Vars<String>().add(body));}
0710     /**
0711      * <p>Creates a JavaScript function with an argument name.</p>
0712      * <p>A function is a fundamental data-type in JavaScript. Note that although functions 
0713      * may be created with this method, this is not efficient, and the preferred way to 
0714      * define functions, in most cases, is to extend {@link Function}.</p>
0715      * @param argname A string literal, naming an argument of the function being created.
0716      * @param body A string that specifies the body of the function.
0717      * @return A newly created function. Invoking it executes the JavaScript code specified 
0718      * by <tt>body</tt>.
0719      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> if there was a 
0720      * JavaScript syntax error in one of the value of the variable arguments or <tt>body</tt>. 
0721      * See {@link Js#err(Object)} and {@link js.core.JsSyntaxError} for JS Simulation.
0722      * @see #function()
0723      * @see #function(String)
0724      * @see #function(Vars, String)
0725      * @see Function
0726      * @see js.core.JsGlobal.Function#create(String, String)
0727      * @see js.core.JsGlobal.Function#create(Vars, String)
0728      * @since 1.0
0729      * @javascript Re-compilers must replace the static invocation of this method with the 
0730      * JavaScript invocation:
0731      * <pre>new Function(argname, body)</pre>
0732      * where <tt>argname</tt> must be a string literal and converted into an argument name.
0733      */
0734     public static final <T> JsFunction<T> function(String argname, String body) { return s().function(new Vars<String>().add(argname).add(body));}
0735     /**
0736      * <p>Creates a JavaScript function.</p>
0737      * <p>A function is a fundamental data-type in JavaScript. Note that although functions 
0738      * may be created with this method, this is not efficient, and the preferred way to 
0739      * define functions, in most cases, is to extend {@link Function}.</p>
0740      * @param argnames A list of the argument values, each naming one or more arguments of the 
0741      * function being created.
0742      * @param body A string that specifies the body of the function.
0743      * @return A newly created function. Invoking it executes the JavaScript code specified 
0744      * by <tt>body</tt>.
0745      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> if there was a 
0746      * JavaScript syntax error in one of the value of the variable arguments and <tt>body</tt>. 
0747      * See {@link Js#err(Object)} and {@link js.core.JsSyntaxError} for JS Simulation.
0748      * @see #function()
0749      * @see #function(String)
0750      * @see #function(String, String)
0751      * @see Function
0752      * @see js.core.JsGlobal.Function#create(Vars, String)
0753      * @since 1.0
0754      * @javascript Re-compilers must replace the static invocation of this method with the 
0755      * JavaScript invocation:
0756      * <pre>new Function(argnames, body)</pre>
0757      * where <tt>argnames</tt> must be a list of string literals and expanded into 
0758      * comma-separated argument names.
0759      */
0760     public static final <T> JsFunction<T> function(Vars<String> argnames, String body) { return s().function(new Vars<String>().addAll(argnames).add(body));}
0761 
0762     /**
0763      * <p>Creates an integer literal.</p>
0764      * <p>This method is used to create formatted integer literal in re-compiled JavaScript 
0765      * code. A re-compiler leaves the literal as it is without even parsing check but JS 
0766      * Simulations parse it to an integer and throws RuntimeException if it is malformatted.</p>
0767      * @param s The literal text of an integer.
0768      * @return The integer literal.
0769      * @since 1.0
0770      * @javascript Re-compilers must replace the static invocation of this method with the 
0771      * JavaScript invocation:
0772      * <pre>s</pre>
0773      * where <tt>s</tt> must be a string literals and converted into an integer literal.
0774      */
0775     public static final int integer(String s) { return s().integer(s);}
0776     /**
0777      * <p>Creates a number literal.</p>
0778      * <p>This method is used to create formatted number literal in re-compiled JavaScript 
0779      * code. A re-compiler leaves the literal as it is without even parsing check but JS 
0780      * Simulations parse it to a number and throws RuntimeException if it is malformatted.</p>
0781      * @param s The literal text of a number.
0782      * @return The numberer literal.
0783      * @since 1.0
0784      * @javascript Re-compilers must replace the static invocation of this method with the 
0785      * JavaScript invocation:
0786      * <pre>s</pre>
0787      * where <tt>s</tt> must be a string literal and converted into a number literal.
0788      */
0789     public static final Number number(String s) { return s().number(s);}
0790 
0791     /**
0792      * <p>Creates an empty array.</p>
0793      * @return The empty array.
0794      * @see #array(Object[])
0795      * @see #array(boolean[])
0796      * @see #array(byte[])
0797      * @see #array(char[])
0798      * @see #array(short[])
0799      * @see #array(int[])
0800      * @see #array(long[])
0801      * @see #array(float[])
0802      * @see #array(double[])
0803      * @see Vars#var()
0804      * @see js.core.JsArray#JsArray()
0805      * @see js.core.JsGlobal.Array#create()
0806      * @since 1.0
0807      * @javascript Re-compilers must replace the static invocation of this method with the 
0808      * JavaScript invocation:
0809      * <pre>[]</pre>
0810      */
0811     public static final <T> ArrayLike<T> array() { return s().array();}
0812     /**
0813      * <p>Gets the array-like representation of a generic array.</p>
0814      * @param a A generic array
0815      * @return The array-like representation.
0816      * @see #array(boolean[])
0817      * @see #array(byte[])
0818      * @see #array(char[])
0819      * @see #array(short[])
0820      * @see #array(int[])
0821      * @see #array(long[])
0822      * @see #array(float[])
0823      * @see #array(double[])
0824      * @see js.core.JsArray#JsArray(js.core.JsObject)
0825      * @see js.core.JsArray#JsArray(Object[])
0826      * @see js.core.JsGlobal.Array#create(Object)
0827      * @since 1.0
0828      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0829      * replacing it with its only argument.
0830      */
0831     public static final <T> ArrayLike<T> array(T[] a) { return s().array(a);}
0832     /**
0833      * <p>Gets the array-like representation of a boolean array.</p>
0834      * @param a A boolean array
0835      * @return The array-like representation.
0836      * @see #array(Object[])
0837      * @see #array(byte[])
0838      * @see #array(char[])
0839      * @see #array(short[])
0840      * @see #array(int[])
0841      * @see #array(long[])
0842      * @see #array(float[])
0843      * @see #array(double[])
0844      * @see js.core.JsArray#JsArray(boolean[])
0845      * @see js.core.JsArray#JsArray(js.core.JsObject)
0846      * @see js.core.JsGlobal.Array#create(Object)
0847      * @since 1.0
0848      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0849      * replacing it with its only argument.
0850      */
0851     public static final ArrayLike<Boolean>   array(boolean[] a) { return s().array(a);}
0852     /**
0853      * <p>Gets the array-like representation of a byte array.</p>
0854      * @param a A byte array
0855      * @return The array-like representation.
0856      * @see #array(Object[])
0857      * @see #array(boolean[])
0858      * @see #array(char[])
0859      * @see #array(short[])
0860      * @see #array(int[])
0861      * @see #array(long[])
0862      * @see #array(float[])
0863      * @see #array(double[])
0864      * @see js.core.JsArray#JsArray(byte[])
0865      * @see js.core.JsArray#JsArray(js.core.JsObject)
0866      * @see js.core.JsGlobal.Array#create(Object)
0867      * @since 1.0
0868      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0869      * replacing it with its only argument.
0870      */
0871     public static final ArrayLike<Byte>      array(byte   [] a) { return s().array(a);}
0872     /**
0873      * <p>Gets the array-like representation of a char array.</p>
0874      * @param a A char array
0875      * @return The array-like representation.
0876      * @see #array(Object[])
0877      * @see #array(boolean[])
0878      * @see #array(byte[])
0879      * @see #array(short[])
0880      * @see #array(int[])
0881      * @see #array(long[])
0882      * @see #array(float[])
0883      * @see #array(double[])
0884      * @see js.core.JsArray#JsArray(char[])
0885      * @see js.core.JsArray#JsArray(js.core.JsObject)
0886      * @see js.core.JsGlobal.Array#create(Object)
0887      * @since 1.0
0888      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0889      * replacing it with its only argument.
0890      */
0891     public static final ArrayLike<Character> array(char   [] a) { return s().array(a);}
0892     /**
0893      * <p>Gets the array-like representation of a short array.</p>
0894      * @param a A short array
0895      * @return The array-like representation.
0896      * @see #array(Object[])
0897      * @see #array(boolean[])
0898      * @see #array(byte[])
0899      * @see #array(char[])
0900      * @see #array(int[])
0901      * @see #array(long[])
0902      * @see #array(float[])
0903      * @see #array(double[])
0904      * @see js.core.JsArray#JsArray(short[])
0905      * @see js.core.JsArray#JsArray(js.core.JsObject)
0906      * @see js.core.JsGlobal.Array#create(Object)
0907      * @since 1.0
0908      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0909      * replacing it with its only argument.
0910      */
0911     public static final ArrayLike<Short>     array(short  [] a) { return s().array(a);}
0912     /**
0913      * <p>Gets the array-like representation of an int array.</p>
0914      * @param a An int array
0915      * @return The array-like representation.
0916      * @see #array(Object[])
0917      * @see #array(boolean[])
0918      * @see #array(byte[])
0919      * @see #array(char[])
0920      * @see #array(short[])
0921      * @see #array(long[])
0922      * @see #array(float[])
0923      * @see #array(double[])
0924      * @see js.core.JsArray#JsArray(int[])
0925      * @see js.core.JsArray#JsArray(js.core.JsObject)
0926      * @see js.core.JsGlobal.Array#create(Object)
0927      * @since 1.0
0928      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0929      * replacing it with its only argument.
0930      */
0931     public static final ArrayLike<Integer>   array(int    [] a) { return s().array(a);}
0932     /**
0933      * <p>Gets the array-like representation of a long array.</p>
0934      * @param a A long array
0935      * @return The array-like representation.
0936      * @see #array(Object[])
0937      * @see #array(boolean[])
0938      * @see #array(byte[])
0939      * @see #array(char[])
0940      * @see #array(short[])
0941      * @see #array(int[])
0942      * @see #array(float[])
0943      * @see #array(double[])
0944      * @see js.core.JsArray#JsArray(long[])
0945      * @see js.core.JsArray#JsArray(js.core.JsObject)
0946      * @see js.core.JsGlobal.Array#create(Object)
0947      * @since 1.0
0948      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0949      * replacing it with its only argument.
0950      */
0951     public static final ArrayLike<Long>      array(long   [] a) { return s().array(a);}
0952     /**
0953      * <p>Gets the array-like representation of a float array.</p>
0954      * @param a A float array
0955      * @return The array-like representation.
0956      * @see #array(Object[])
0957      * @see #array(boolean[])
0958      * @see #array(byte[])
0959      * @see #array(char[])
0960      * @see #array(short[])
0961      * @see #array(int[])
0962      * @see #array(long[])
0963      * @see #array(double[])
0964      * @see js.core.JsArray#JsArray(float[])
0965      * @see js.core.JsArray#JsArray(js.core.JsObject)
0966      * @see js.core.JsGlobal.Array#create(Object)
0967      * @since 1.0
0968      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0969      * replacing it with its only argument.
0970      */
0971     public static final ArrayLike<Float>     array(float  [] a) { return s().array(a);}
0972     /**
0973      * <p>Gets the array-like representation of a double array.</p>
0974      * @param a A double array
0975      * @return The array-like representation.
0976      * @see #array(Object[])
0977      * @see #array(boolean[])
0978      * @see #array(byte[])
0979      * @see #array(char[])
0980      * @see #array(short[])
0981      * @see #array(int[])
0982      * @see #array(long[])
0983      * @see #array(float[])
0984      * @see js.core.JsArray#JsArray(double[])
0985      * @see js.core.JsArray#JsArray(js.core.JsObject)
0986      * @see js.core.JsGlobal.Array#create(Object)
0987      * @since 1.0
0988      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
0989      * replacing it with its only argument.
0990      */
0991     public static final ArrayLike<Double>    array(double [] a) { return s().array(a);}
0992     /**
0993      * <p>Creates a date object set to the current system date and time.</p>
0994      * @return The newly created date object.
0995      * @see #date(Number)
0996      * @see #date(String)
0997      * @see js.core.JsGlobal.Date#create()
0998      * @see js.core.JsGlobal.Date#create(Vars)
0999      * @since 1.0
1000      * @javascript Re-compilers must replace the static invocation of this method with the 
1001      * JavaScript expression:
1002      * <pre>new Date()</pre>
1003      */
1004     public static final DateLike date() { return s().date();}
1005     /**
1006      * <p>Creates a date object from a numeric representation in milliseconds.</p>
1007      * @param milliseconds A numeric representation of date in milliseconds.
1008      * @return The newly created date object.
1009      * @see #date()
1010      * @see #date(String)
1011      * @see js.core.JsDate#JsDate(Number)
1012      * @see js.core.JsDate#JsDate(NumberLike)
1013      * @see js.core.JsGlobal.Date#create(Number)
1014      * @see js.core.JsGlobal.Date#create(NumberLike)
1015      * @see js.core.JsGlobal.Date#create(Vars)
1016      * @since 1.0
1017      * @javascript Re-compilers must replace the static invocation of this method with the 
1018      * JavaScript expression:
1019      * <pre>new Date(milliseconds)</pre>
1020      */
1021     public static final DateLike date(Number milliseconds) { return s().date(milliseconds);}
1022     /**
1023      * <p>Creates a date object from a string representation.</p>
1024      * @param datestring A string representation of date.
1025      * @return The newly created date object.
1026      * @see #date()
1027      * @see #date(Number)
1028      * @see js.core.JsDate#JsDate(String)
1029      * @see js.core.JsDate#JsDate(StringLike)
1030      * @see js.core.JsGlobal.Date#create(Object)
1031      * @see js.core.JsGlobal.Date#create(Vars)
1032      * @since 1.0
1033      * @javascript Re-compilers must replace the static invocation of this method with the 
1034      * JavaScript expression:
1035      * <pre>new Date(datestring)</pre>
1036      */
1037     public static final DateLike date(String datestring) { return s().date(datestring);}
1038     /**
1039      * <p>Returns the math-like object.</p>
1040      * @return The math-like object.
1041      * @see js.core.JsGlobal.Math
1042      * @see jsx.core.Maths
1043      * @since 1.0
1044      * @javascript Re-compilers must replace the static invocation of this method with the 
1045      * JavaScript expression:
1046      * <pre>Math</pre>
1047      */
1048     public static final MathLike math() { return s().math();}
1049     /**
1050      * <p>Creates and returns a newly created object.</p>
1051      * @return The newly created object.
1052      * @see #object(Object)
1053      * @see Initializer#var()
1054      * @see js.core.JsObject#JsObject()
1055      * @see js.core.JsGlobal.Object#create()
1056      * @see js.core.JsGlobal.Object#invoke()
1057      * @since 1.0
1058      * @javascript Re-compilers must replace the static invocation of this method with the 
1059      * JavaScript expression:
1060      * <pre>{}</pre>
1061      */
1062     public static final ObjectLike object() { return s().object();}
1063     /**
1064      * <p>Converts a value to an object and returns it.</p>
1065      * @param o A value to be converted to object. If this argument is a primitive value, 
1066      * this method creates a corresponding object for it. Otherwise, the method returns 
1067      * the object itself.
1068      * @return The converted or created object. If the argument is a primitive value, 
1069      * this method returns a corresponding object for it. Otherwise, the method returns 
1070      * the object argument itself.
1071      * @see #object()
1072      * @see js.core.JsObject#JsObject(JsObject)
1073      * @see js.core.JsGlobal.Object#create(Boolean)
1074      * @see js.core.JsGlobal.Object#create(JsBoolean)
1075      * @see js.core.JsGlobal.Object#create(Value)
1076      * @see js.core.JsGlobal.Object#create(Number)
1077      * @see js.core.JsGlobal.Object#create(NumberLike)
1078      * @see js.core.JsGlobal.Object#create(String)
1079      * @see js.core.JsGlobal.Object#create(StringLike)
1080      * @see js.core.JsGlobal.Object#invoke(Boolean)
1081      * @see js.core.JsGlobal.Object#invoke(JsBoolean)
1082      * @see js.core.JsGlobal.Object#invoke(Value)
1083      * @see js.core.JsGlobal.Object#invoke(Number)
1084      * @see js.core.JsGlobal.Object#invoke(NumberLike)
1085      * @see js.core.JsGlobal.Object#invoke(String)
1086      * @see js.core.JsGlobal.Object#invoke(StringLike)
1087      * @since 1.0
1088      * @javascript Re-compilers must replace the static invocation of this method with the 
1089      * JavaScript expression:
1090      * <pre>Object(o)</pre>
1091      */
1092     public static final ObjectLike object(Object o) { return s().object(o);}
1093     /**
1094      * <p>Creates a regular expression with the specified pattern.</p>
1095      * @param regex A string that specifies the pattern of the regular expression.
1096      * @return A new regular expression object, with the specified pattern.
1097      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> If <tt>regex</tt> 
1098      * is not a legal regular expression. See {@link Js#err(Object)} and {@link js.core.JsSyntaxError} 
1099      * for JS Simulation.
1100      * @see #re(String, String)
1101      * @see js.core.JsRegExp#JsRegExp(String)
1102      * @see js.core.JsGlobal.RegExp#create(Object)
1103      * @see js.core.JsGlobal.RegExp#create(Vars)
1104      * @see js.core.JsGlobal.RegExp#invoke(Object)
1105      * @see js.core.JsGlobal.RegExp#invoke(Vars)
1106      * @since 1.0
1107      * @javascript Re-compilers must replace the static invocation of this method with the 
1108      * JavaScript expression:
1109      * <pre>RegExp(regex)</pre>
1110      * or if <tt>regex</tt> is a string literal,
1111      * <pre>/regex/</pre>
1112      * where <tt>regex</tt> is converted to a literal text.
1113      */
1114     public static final RegExpLike re(String regex) { return s().re(regex);}
1115     /**
1116      * <p>Creates a regular expression with the specified pattern and flags.</p>
1117      * @param regex A string that specifies the pattern of the regular expression.
1118      * @param flags An optional string containing any of the "g", "i", and "m" attributes 
1119      * that specify global, case-insensitive, and multiline matches, respectively. The "m" 
1120      * attribute is not available prior to ECMAScript standardization.
1121      * @return A new regular expression object, with the specified pattern and flags.
1122      * @throws RuntimeException JavaScript throws a <tt>SyntaxError</tt> If <tt>regex</tt> 
1123      * is not a legal regular expression, or if <tt>flags</tt> contains characters other than 
1124      * "g", "i", and "m". See {@link Js#err(Object)} and {@link js.core.JsSyntaxError} for 
1125      * JS Simulation.
1126      * @see #re(String)
1127      * @see js.core.JsRegExp#JsRegExp(String, String)
1128      * @see js.core.JsGlobal.RegExp#create(Object, Object)
1129      * @see js.core.JsGlobal.RegExp#create(Vars)
1130      * @see js.core.JsGlobal.RegExp#invoke(Object, Object)
1131      * @see js.core.JsGlobal.RegExp#invoke(Vars)
1132      * @since 1.0
1133      * @javascript Re-compilers must replace this static invocation with the JavaScript expression:
1134      * <pre>RegExp(regex, flags)</pre>
1135      * or if <tt>regex</tt> and <tt>flags</tt> are both string literals, 
1136      * <pre>/regex/flags</pre>
1137      * where <tt>regex</tt> and <tt>flags</tt> are converted to literal texts.
1138      */
1139     public static final RegExpLike re(String regex, String flags) { return s().re(regex, flags);}
1140     /**
1141      * <p>Returns an instance of XMLHttpRequest in Java version.</p>
1142      * @return The instance of XMLHttpRequest in Java version.
1143      * @see js.dom.DOM.XMLHttpRequest#create()
1144      * @see js.dom.DOM.XMLHttpRequest#invoke()
1145      * @see jsx.http.Http#create()
1146      * @see jsx.http.Http#create2()
1147      * @since 1.0
1148      * @javascript Re-compilers must replace the static invocation of this method with the 
1149      * JavaScript expression:
1150      * <pre>new XMLHttpRequest()</pre>
1151      */
1152     public static final JsXMLHttpRequest http() { return s().http();}
1153     /**
1154      * <p>Creates an OLE Automation (ActiveX) object for Internet Explorer.</p>
1155      * @param cls The class of the OLE Automation (ActiveX) object being created.
1156      * @return The newly created OLE Automation (ActiveX) object.
1157      * @see js.dom.DOM.ActiveXObject#create(Object)
1158      * @see js.dom.DOM.ActiveXObject#create(String)
1159      * @see js.dom.DOM.ActiveXObject#create(Vars)
1160      * @see jsx.http.Http#create()
1161      * @see jsx.http.Http#create2()
1162      * @since 1.0
1163      * @javascript Re-compilers must replace the static invocation of this method with the 
1164      * JavaScript expression:
1165      * <pre>new ActiveXObject(cls)</pre>
1166      */
1167     public static final JsObject activeX(String cls) { return s().activeX(cls);}
1168 
1169     /**
1170      * <p>Connects to a Java class in an applet and returns a LiveConnect class.</p>
1171      * @param applet The applet ID where the Java class is to be connected to.
1172      * @param cls The Java class to be connected to.
1173      * @return The LiveConnect class connected to the Java class.
1174      * @see #connect(Object)
1175      * @since 1.0
1176      * @javascript Re-compilers must replace the static invocation of this method with the 
1177      * JavaScript expression:
1178      * <pre>applet.cls</pre>
1179      * where <tt>applet</tt> and <tt>cls</tt> must be both string literals and converted 
1180      * into identifiers.
1181      */
1182     public static final LiveClass connect(String applet, String cls) { return s().connect(applet, cls);}
1183     /**
1184      * <p>Connects to a Java object and returns a LiveConnect object.</p>
1185      * @param obj The Java object to be connected to.
1186      * @return The LiveConnect object connected to the Java object.
1187      * @see #connect(String, String)
1188      * @since 1.0
1189      * @javascript Re-compilers must replace this static invocation with the JavaScript expression:
1190      * <pre>obj</pre>
1191      * where <tt>obj</tt> must be a string literal and converted to an identifier.
1192      */
1193     public static final LiveObject connect(Object obj) { return s().connect(obj);}
1194 
1195     private static final class Err extends RuntimeException
1196     {
1197         private static final long serialVersionUID = 1L;
1198         private final Object var;
1199 
1200         private Err(Object var) {
1201             this.var = var;
1202         }
1203         @Override
1204         public final String toString() {
1205             return Js.toString(var);
1206         }
1207         public final String typeof() {
1208             return Js.typeof(var);
1209         }
1210         public final boolean undefined() {
1211             return Js.undefined(var);
1212         }
1213         public final Object valueOf() {
1214             return Js.valueOf(var);
1215         }
1216     }
1217     /**
1218      * <p>Makes a variable runtime throwable, resembling JavaScript.</p>
1219      * @param v Any value or object.
1220      * @return A <tt>RuntimeException</tt> wrapping the value or object.
1221      * @since 1.0
1222      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1223      * replacing it with its only argument.
1224      */
1225     public static final RuntimeException err(Object v) {
1226         return v instanceof Err ? (Err)v : new Err(v);
1227     }
1228     /**
1229      * <p>Gets the value or object contained in a <tt>RuntimeException</tt> object 
1230      * thrown by JS Simulation.</p>
1231      * @param e The <tt>RuntimeException</tt> object thrown by JS Simulation.
1232      * @return The value or object contained in the <tt>RuntimeException</tt> object.
1233      * @since 1.0
1234      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1235      * replacing it with its only argument.
1236      */
1237     public static final Object err(RuntimeException e) {
1238         return e instanceof Err ? ((Err)e).var : s().err(e);
1239     }
1240     /**
1241      * <p>Checks if a variable is undefined.</p>
1242      * @param v Any value or object.
1243      * @return <tt>true</tt> if <tt>v</tt> is undefined; <tt>false</tt>, otherwise.
1244      * @since 1.0
1245      * @javascript Re-compilers must replace the static invocation of this method with the 
1246      * JavaScript expression:
1247      * <pre>v===undefined</pre>
1248      */
1249     public static final boolean undefined(Object v) {
1250         return v == null ||
1251                v instanceof Err && ((Err)v).undefined() ||
1252                v instanceof Var<?> && ((Var<?>)v).undefined();
1253     }
1254     /**
1255      * <p>Checks if a variable is defined.</p>
1256      * @param v Any value or object.
1257      * @return <tt>true</tt> if <tt>v</tt> is defined; <tt>false</tt>, otherwise.
1258      * @since 1.0
1259      * @javascript Re-compilers must replace the static invocation of this method with the 
1260      * JavaScript expression:
1261      * <pre>v!==undefined</pre>
1262      */
1263     public static final boolean defined(Object v) {
1264         return !undefined(v);
1265     }
1266     /**
1267      * <p>Checks if a variable represents a Java object.</p>
1268      * @param v Any value or object.
1269      * @return <tt>true</tt> if <tt>v</tt> is Java; <tt>false</tt>, otherwise.
1270      * @since 1.0
1271      * @javascript Re-compilers must replace the static invocation of this method with the 
1272      * JavaScript expression:
1273      * <pre>v instanceof JavaObject</pre>
1274      */
1275     public static final boolean isJavaObject(Object v) {
1276         return s().isJavaObject(v);
1277     }
1278     /**
1279      * <p>Returns a string representation of a variable.</p>
1280      * @param v Any value or object.
1281      * @return The string representation of the value or object.
1282      * @since 1.0
1283      * @javascript Re-compilers must replace the static invocation of this method with the 
1284      * JavaScript expression:
1285      * <pre>"" + v</pre>
1286      */
1287     public static final String toString(Object v) {
1288         return undefined(v) ? "undefined" : v.toString();
1289     }
1290 
1291     /**
1292      * <p>Logically evaluates a variable.</p>
1293      * @param v The variable.
1294      * @return The logical value of the variable.
1295      * @since 1.0
1296      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1297      * replacing it with its only argument.
1298      */
1299     public static final boolean be(boolean v) {
1300         return v;
1301     }
1302     /**
1303      * <p>Logically evaluates a variable.</p>
1304      * @param v The variable.
1305      * @return The logical value of the variable.
1306      * @since 1.0
1307      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1308      * replacing it with its only argument.
1309      */
1310     public static final boolean be(Boolean v) {
1311         return v != null && v;
1312     }
1313     /**
1314      * <p>Logically evaluates a variable.</p>
1315      * @param v The variable.
1316      * @return The logical value of the variable.
1317      * @since 1.0
1318      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1319      * replacing it with its only argument.
1320      */
1321     public static final boolean be(Character v) {
1322         return v != null && v != 0;
1323     }
1324     /**
1325      * <p>Logically evaluates a variable.</p>
1326      * @param v The variable.
1327      * @return The logical value of the variable.
1328      * @since 1.0
1329      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1330      * replacing it with its only argument.
1331      */
1332     public static final boolean be(char v) {
1333         return v != 0;
1334     }
1335     /**
1336      * <p>Logically evaluates a variable.</p>
1337      * @param v The variable.
1338      * @return The logical value of the variable.
1339      * @since 1.0
1340      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1341      * replacing it with its only argument.
1342      */
1343     public static final boolean be(Number v) {
1344         return v != null && v.doubleValue() != 0;
1345     }
1346     /**
1347      * <p>Logically evaluates a variable.</p>
1348      * @param v The variable.
1349      * @return The logical value of the variable.
1350      * @since 1.0
1351      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1352      * replacing it with its only argument.
1353      */
1354     public static final boolean be(byte v) {
1355         return v != 0;
1356     }
1357     /**
1358      * <p>Logically evaluates a variable.</p>
1359      * @param v The variable.
1360      * @return The logical value of the variable.
1361      * @since 1.0
1362      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1363      * replacing it with its only argument.
1364      */
1365     public static final boolean be(short v) {
1366         return v != 0;
1367     }
1368     /**
1369      * <p>Logically evaluates a variable.</p>
1370      * @param v The variable.
1371      * @return The logical value of the variable.
1372      * @since 1.0
1373      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1374      * replacing it with its only argument.
1375      */
1376     public static final boolean be(int v) {
1377         return v != 0;
1378     }
1379     /**
1380      * <p>Logically evaluates a variable.</p>
1381      * @param v The variable.
1382      * @return The logical value of the variable.
1383      * @since 1.0
1384      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1385      * replacing it with its only argument.
1386      */
1387     public static final boolean be(long v) {
1388         return v != 0;
1389     }
1390     /**
1391      * <p>Logically evaluates a variable.</p>
1392      * @param v The variable.
1393      * @return The logical value of the variable.
1394      * @since 1.0
1395      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1396      * replacing it with its only argument.
1397      */
1398     public static final boolean be(float v) {
1399         return v != 0;
1400     }
1401     /**
1402      * <p>Logically evaluates a variable.</p>
1403      * @param v The variable.
1404      * @return The logical value of the variable.
1405      * @since 1.0
1406      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1407      * replacing it with its only argument.
1408      */
1409     public static final boolean be(double v) {
1410         return v != 0;
1411     }
1412     /**
1413      * <p>Logically evaluates a variable.</p>
1414      * @param v The variable.
1415      * @return The logical value of the variable.
1416      * @since 1.0
1417      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1418      * replacing it with its only argument.
1419      */
1420     public static final boolean be(String v) {
1421         return v != null && v.length() > 0;
1422     }
1423     /**
1424      * <p>Logically evaluates a variable.</p>
1425      * @param v The variable.
1426      * @return The logical value of the variable.
1427      * @since 1.0
1428      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1429      * replacing it with its only argument.
1430      */
1431     public static final boolean be(ArrayLike<?> v) {
1432         return defined(v) && v.length() > 0;
1433     }
1434     /**
1435      * <p>Logically evaluates a variable.</p>
1436      * @param v The variable.
1437      * @return The logical value of the variable.
1438      * @since 1.0
1439      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1440      * replacing it with its only argument.
1441      */
1442     public static final boolean be(JsArray v) {
1443         return defined(v) && v.length() > 0;
1444     }
1445     /**
1446      * <p>Logically evaluates a variable.</p>
1447      * @param v The variable.
1448      * @return The logical value of the variable.
1449      * @since 1.0
1450      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1451      * replacing it with its only argument.
1452      */
1453     public static final boolean be(Var<?> v) {
1454         return v instanceof ArrayLike<?> ? be((ArrayLike<?>)v) :
1455                v instanceof NumberLike<?>  ||
1456                v instanceof StringLike ? be(v.valueOf()) : defined(v);
1457     }
1458     /**
1459      * <p>Logically evaluates a variable.</p>
1460      * @param v The variable.
1461      * @return The logical value of the variable.
1462      * @since 1.0
1463      * @javascript Re-compilers must ignore the static invocation of this method, that is, 
1464      * replacing it with its only argument.
1465      */
1466     public static final boolean be(Object v) {
1467         return v instanceof Boolean      ? be((Boolean     )v) :
1468                v instanceof Character    ? be((Character   )v) :
1469                v instanceof Number       ? be((Number      )v) :
1470                v instanceof String       ? be((String      )v) :
1471                v instanceof ArrayLike<?> ? be((ArrayLike<?>)v) :
1472                v instanceof Var<?>       ? be((Var<?>      )v) : v != null;
1473     }
1474 
1475     /**
1476      * <p>Returns a string indicating the data-type of the argument.</p>
1477      * <p>Simulating the JavaScript <tt>typeof</tt> operator and <tt>typeof()</tt> 
1478      * function, this invocation evaluates to "number", "string", or "boolean" if the  
1479      * argument is a number, string, or boolean value. It evaluates to "object" for objects 
1480      * and arrays. It evaluates to "function" for function instance and to "undefined" if 
1481      * the argument is undefined.</p>
1482      * @param v Any value or object.
1483      * @return A string indicating the data-type of the argument.
1484      * @since 1.0
1485      * @javascript Re-compilers must replace the static invocation of this method with the 
1486      * JavaScript expression:
1487      * <pre>typeof v</pre>
1488      */
1489     public static final String typeof(Object v) {
1490         return v == null ? "undefined" :
1491                v instanceof Boolean ? "boolean" :
1492                v instanceof Function<?> ? "function" :
1493                v instanceof Character ? "number" :
1494                v instanceof Long ? "object" :
1495                v instanceof Number ? "number" :
1496                v instanceof String ? "string" :
1497                v instanceof Err ? ((Err)v).typeof() :
1498                v instanceof Var<?> ? ((Var<?>)v).typeof() : "object";
1499     }
1500 
1501     /**
1502      * <p>Returns the primitive value associated with the argument, if there is one. 
1503      * @param v Any value or object.
1504      * @return The primitive string value associated with the argument.
1505      * @since 1.0
1506      * @javascript Re-compilers must replace the static invocation of this method with the 
1507      * JavaScript expression:
1508      * <pre>v.valueOf()</pre>
1509      */
1510     public static final Boolean valueOf(Boolean v) {
1511         return v;
1512     }
1513     /**
1514      * <p>Returns the primitive value associated with the argument, if there is one. 
1515      * @param v Any value or object.
1516      * @return The primitive string value associated with the argument.
1517      * @since 1.0
1518      * @javascript Re-compilers must replace the static invocation of this method with the 
1519      * JavaScript expression:
1520      * <pre>v.valueOf()</pre>
1521      */
1522     public static final Number valueOf(Number v) {
1523         return v;
1524     }
1525     /**
1526      * <p>Returns the primitive value associated with the argument, if there is one. 
1527      * @param v Any value or object.
1528      * @return The primitive string value associated with the argument.
1529      * @since 1.0
1530      * @javascript Re-compilers must replace the static invocation of this method with the 
1531      * JavaScript expression:
1532      * <pre>v.valueOf()</pre>
1533      */
1534     public static final Byte valueOf(Byte v) {
1535         return v;
1536     }
1537     /**
1538      * <p>Returns the primitive value associated with the argument, if there is one. 
1539      * @param v Any value or object.
1540      * @return The primitive string value associated with the argument.
1541      * @since 1.0
1542      * @javascript Re-compilers must replace the static invocation of this method with the 
1543      * JavaScript expression:
1544      * <pre>v.valueOf()</pre>
1545      */
1546     public static final Short valueOf(Character v) {
1547         return v == null ? null : (short)v.charValue();
1548     }
1549     /**
1550      * <p>Returns the primitive value associated with the argument, if there is one. 
1551      * @param v Any value or object.
1552      * @return The primitive string value associated with the argument.
1553      * @since 1.0
1554      * @javascript Re-compilers must replace the static invocation of this method with the 
1555      * JavaScript expression:
1556      * <pre>v.valueOf()</pre>
1557      */
1558     public static final Short valueOf(Short v) {
1559         return v;
1560     }
1561     /**
1562      * <p>Returns the primitive value associated with the argument, if there is one. 
1563      * @param v Any value or object.
1564      * @return The primitive string value associated with the argument.
1565      * @since 1.0
1566      * @javascript Re-compilers must replace the static invocation of this method with the 
1567      * JavaScript expression:
1568      * <pre>v.valueOf()</pre>
1569      */
1570     public static final Integer valueOf(Integer v) {
1571         return v;
1572     }
1573     /**
1574      * <p>Returns the primitive value associated with the argument, if there is one. 
1575      * @param v Any value or object.
1576      * @return The primitive string value associated with the argument.
1577      * @since 1.0
1578      * @javascript Re-compilers must replace the static invocation of this method with the 
1579      * JavaScript expression:
1580      * <pre>v.valueOf()</pre>
1581      */
1582     public static final Long valueOf(Long v) {
1583         return v;
1584     }
1585     /**
1586      * <p>Returns the primitive value associated with the argument, if there is one. 
1587      * @param v Any value or object.
1588      * @return The primitive string value associated with the argument.
1589      * @since 1.0
1590      * @javascript Re-compilers must replace the static invocation of this method with the 
1591      * JavaScript expression:
1592      * <pre>v.valueOf()</pre>
1593      */
1594     public static final Float valueOf(Float v) {
1595         return v;
1596     }
1597     /**
1598      * <p>Returns the primitive value associated with the argument, if there is one. 
1599      * @param v Any value or object.
1600      * @return The primitive string value associated with the argument.
1601      * @since 1.0
1602      * @javascript Re-compilers must replace the static invocation of this method with the 
1603      * JavaScript expression:
1604      * <pre>v.valueOf()</pre>
1605      */
1606     public static final Double valueOf(Double v) {
1607         return v;
1608     }
1609     /**
1610      * <p>Returns the primitive value associated with the argument, if there is one. 
1611      * @param v Any value or object.
1612      * @return The primitive string value associated with the argument.
1613      * @since 1.0
1614      * @javascript Re-compilers must replace the static invocation of this method with the 
1615      * JavaScript expression:
1616      * <pre>v.valueOf()</pre>
1617      */
1618     public static final String valueOf(String v) {
1619         return v;
1620     }
1621     /**
1622      * <p>Returns the primitive value associated with the argument, if there is one. 
1623      * @param v Any value or object.
1624      * @return The primitive string value associated with the argument.
1625      * @since 1.0
1626      * @javascript Re-compilers must replace the static invocation of this method with the 
1627      * JavaScript expression:
1628      * <pre>v.valueOf()</pre>
1629      */
1630     public static final <T> ArrayLike<T> valueOf(ArrayLike<T> v) {
1631         return v == null ? null : v.valueOf();
1632     }
1633     /**
1634      * <p>Returns the primitive value associated with the argument, if there is one. 
1635      * @param v Any value or object.
1636      * @return The primitive string value associated with the argument.
1637      * @since 1.0
1638      * @javascript Re-compilers must replace the static invocation of this method with the 
1639      * JavaScript expression:
1640      * <pre>v.valueOf()</pre>
1641      */
1642     @SuppressWarnings("unchecked")
1643     public static final <T extends JsObject> T valueOf(T v) {
1644         return v == null ? null : (T)v.valueOf();
1645     }
1646     /**
1647      * <p>Returns the primitive value associated with the argument, if there is one. 
1648      * @param v Any value or object.
1649      * @return The primitive string value associated with the argument.
1650      * @since 1.0
1651      * @javascript Re-compilers must replace the static invocation of this method with the 
1652      * JavaScript expression:
1653      * <pre>v.valueOf()</pre>
1654      */
1655     public static final Boolean valueOf(JsBoolean v) {
1656         return v == null ? null : v.valueOf();
1657     }
1658     /**
1659      * <p>Returns the primitive value associated with the argument, if there is one. 
1660      * @param v Any value or object.
1661      * @return The primitive string value associated with the argument.
1662      * @since 1.0
1663      * @javascript Re-compilers must replace the static invocation of this method with the 
1664      * JavaScript expression:
1665      * <pre>v.valueOf()</pre>
1666      */
1667     public static final Number valueOf(DateLike v) {
1668         return v == null ? null : v.valueOf();
1669     }
1670     /**
1671      * <p>Returns the primitive value associated with the argument, if there is one. 
1672      * @param v Any value or object.
1673      * @return The primitive string value associated with the argument.
1674      * @since 1.0
1675      * @javascript Re-compilers must replace the static invocation of this method with the 
1676      * JavaScript expression:
1677      * <pre>v.valueOf()</pre>
1678      */
1679     public static final <T> JsFunction<T> valueOf(Function<T> v) {
1680         return v == null ? null : v.valueOf();
1681     }
1682     /**
1683      * <p>Returns the primitive value associated with the argument, if there is one. 
1684      * @param v Any value or object.
1685      * @return The primitive string value associated with the argument.
1686      * @since 1.0
1687      * @javascript Re-compilers must replace the static invocation of this method with the 
1688      * JavaScript expression:
1689      * <pre>v.valueOf()</pre>
1690      */
1691     public static final <T extends Number> T valueOf(NumberLike<T> v) {
1692         return v == null ? null : v.valueOf();
1693     }
1694     /**
1695      * <p>Returns the primitive value associated with the argument, if there is one. 
1696      * @param v Any value or object.
1697      * @return The primitive string value associated with the argument.
1698      * @since 1.0
1699      * @javascript Re-compilers must replace the static invocation of this method with the 
1700      * JavaScript expression:
1701      * <pre>v.valueOf()</pre>
1702      */
1703     public static final Number valueOf(JsNumber v) {
1704         return v == null ? null : v.valueOf();
1705     }
1706     /**
1707      * <p>Returns the primitive value associated with the argument, if there is one. 
1708      * @param v Any value or object.
1709      * @return The primitive string value associated with the argument.
1710      * @since 1.0
1711      * @javascript Re-compilers must replace the static invocation of this method with the 
1712      * JavaScript expression:
1713      * <pre>v.valueOf()</pre>
1714      */
1715     public static final String valueOf(StringLike v) {
1716         return v == null ? null : v.valueOf();
1717     }
1718     /**
1719      * <p>Returns the primitive value associated with the argument, if there is one. 
1720      * @param v Any value or object.
1721      * @return The primitive string value associated with the argument.
1722      * @since 1.0
1723      * @javascript Re-compilers must replace the static invocation of this method with the 
1724      * JavaScript expression:
1725      * <pre>v.valueOf()</pre>
1726      */
1727     public static final String valueOf(JsString v) {
1728         return v == null ? null : v.valueOf();
1729     }
1730     /**
1731      * <p>Returns the primitive value associated with the argument, if there is one. 
1732      * @param v Any value or object.
1733      * @return The primitive string value associated with the argument.
1734      * @since 1.0
1735      * @javascript Re-compilers must replace the static invocation of this method with the 
1736      * JavaScript expression:
1737      * <pre>v.valueOf()</pre>
1738      */
1739     public static final <T> T valueOf(Var<T> v) {
1740         return v == null ? null : v.var();
1741     }
1742     /**
1743      * <p>Returns the primitive value associated with the argument, if there is one. 
1744      * @param v Any value or object.
1745      * @return The primitive string value associated with the argument.
1746      * @since 1.0
1747      * @javascript Re-compilers must replace the static invocation of this method with the 
1748      * JavaScript expression:
1749      * <pre>v.valueOf()</pre>
1750      */
1751     public static final Object valueOf(Object v) {
1752         return v == null ? null :
1753                v instanceof Function<?> ? ((Function<?>)v).valueOf() :
1754                v instanceof Var<?> ? ((Var<?>)v).valueOf() :
1755                v instanceof Err ? ((Err)v).valueOf() : v;
1756     }
1757 
1758     /**
1759      * <p>Undefines a variable.</p>
1760      * @param var The variable to delete.
1761      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1762      * @since 1.0
1763      * @javascript Re-compilers must replace the static invocation of this method with the 
1764      * JavaScript expression:
1765      * <pre>delete var</pre>
1766      */
1767     public static final boolean delete(Value<?> var) { 
1768         return var == null ? false : var.delete();
1769     }
1770     /**
1771      * <p>Undefines a variable.</p>
1772      * @param var The variable to delete.
1773      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1774      * @since 1.0
1775      * @javascript Re-compilers must replace the static invocation of this method with the 
1776      * JavaScript expression:
1777      * <pre>delete var</pre>
1778      */
1779     public static final boolean delete(Var<? extends JsObject> var) { 
1780         return var == null ? false : delete(var.var());
1781     }
1782     /**
1783      * <p>Undefines a variable.</p>
1784      * @param var The variable to delete.
1785      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1786      * @since 1.0
1787      * @javascript Re-compilers must replace the static invocation of this method with the 
1788      * JavaScript expression:
1789      * <pre>delete var</pre>
1790      */
1791     public static final boolean delete(JsObject var) { 
1792         return var == null ? false : var.delete();
1793     }
1794     /**
1795      * <p>Undefines a property.</p>
1796      * @param var The variable to delete a property from.
1797      * @param p The property to delete.
1798      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1799      * @since 1.0
1800      * @javascript Re-compilers must replace the static invocation of this method with the 
1801      * JavaScript expression:
1802      * <pre>delete var[p]</pre>
1803      */
1804     public static final boolean delete(Var<? extends JsObject> var, Object p) {
1805         return var == null ? false : delete(var.var(), p);
1806     }
1807     /**
1808      * <p>Undefines a property.</p>
1809      * @param var The variable to delete a property from.
1810      * @param p The property to delete.
1811      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1812      * @since 1.0
1813      * @javascript Re-compilers must replace the static invocation of this method with the 
1814      * JavaScript expression:
1815      * <pre>delete var[p]</pre>
1816      */
1817     public static final boolean delete(ObjectLike var, Object p) {
1818         return var == null ? false : var.delete(p.toString());
1819     }
1820     /**
1821      * <p>Undefines a property.</p>
1822      * @param var The variable to delete a property from.
1823      * @param p The property to delete.
1824      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1825      * @since 1.0
1826      * @javascript Re-compilers must replace the static invocation of this method with the 
1827      * JavaScript expression:
1828      * <pre>delete var[p]</pre>
1829      */
1830     public static final boolean delete(JsObject var, Object p) {
1831         return var == null ? false : var.delete(p.toString());
1832     }
1833     /**
1834      * <p>Delete an array element.</p>
1835      * @param var The array to delete an element from.
1836      * @param i The array index of the element to delete.
1837      * @return <tt>true</tt> if the deletion is successful; Otherwise, <tt>false</tt>.
1838      * @since 1.0
1839      * @javascript Re-compilers must replace the static invocation of this method with the 
1840      * JavaScript expression:
1841      * <pre>delete var[i]</pre>
1842      */
1843     public static final boolean delete(ArrayLike<?> var, int i) {
1844         return var == null ? false : var.delete(i);
1845     }
1846 
1847     /**
1848      * <p>Performs unary negation, resembling the unary minus operator in JavaScript.</p>
1849      * <p>This operation converts a positive value to an equivalently negative value, and 
1850      * vice versa. If the operand is not a number, it attempts to convert it to one.</p>
1851      * @param var Any numeric value.
1852      * @return The negation of the numeric value.
1853      * @since 1.0
1854      * @javascript Re-compilers must replace the static invocation of this method with the 
1855      * JavaScript expression:
1856      * <pre>-var</pre>
1857      */
1858     public static final Number neg(Object var) { return s().neg(s().getNumber(var));}
1859     /**
1860      * <p>Multiplies the two operands, resembling the multiplication operator in JavaScript.</p>
1861      * <p>If used with non-numeric operands, this operation attempts to convert them to 
1862      * numbers.</p>
1863      * @param var Any numeric value.
1864      * @param other Any numeric value.
1865      * @return The product of the two operands.
1866      * @since 1.0
1867      * @javascript Re-compilers must replace the static invocation of this method with the 
1868      * JavaScript expression:
1869      * <pre>var * other</pre>
1870      */
1871     public static final Number mul(Object var, Object other) { return s().mul(s().getNumber(var), s().getNumber(other));}
1872     /**
1873      * <p>Divides the first operand by the second, resembling the division operator 
1874      * in JavaScript.</p>
1875      * <p>Used with non-numeric operands, this operation attempts to convert them to 
1876      * numbers. If you are used to programming languages that distinguish between integer 
1877      * and floating-point numbers, you might expect to get an integer result when you 
1878      * divide one integer by another. In JavaScript, however, all numbers are floating-point, 
1879      * so all division operations have floating-point results. Division by zero yields positive 
1880      * or negative infinity, while <tt>0/0</tt> evaluates to <tt>NaN</tt>.</p>
1881      * @param var Any numeric value.
1882      * @param other Any numeric value.
1883      * @return The quotient of the two operands.
1884      * @since 1.0
1885      * @javascript Re-compilers must replace the static invocation of this method with the 
1886      * JavaScript expression:
1887      * <pre>var / other</pre>
1888      */
1889     public static final Number div(Object var, Object other) { return s().div(s().getNumber(var), s().getNumber(other));}
1890     /**
1891      * <p>Computes the first operand modulo the second operand, resembling the modulo 
1892      * operator in JavaScript.</p>
1893      * <p>The operation returns the remainder when the first operand is divided by the 
1894      * second operand a certain number of times. If used with non-numeric operands, the 
1895      * operation attempts to convert them to numbers. The sign of the result is the same 
1896      * as the sign of the first operand.</p>
1897      * <p>This operation is typically used with integer operands, it also works for 
1898      * floating-point values.</p>
1899      * @param var Any numeric value.
1900      * @param other Any numeric value.
1901      * @return The remainder.
1902      * @since 1.0
1903      * @javascript Re-compilers must replace the static invocation of this method with the 
1904      * JavaScript expression:
1905      * <pre>var % other</pre>
1906      */
1907     public static final Number mod(Object var, Object other) { return s().mod(s().getNumber(var), s().getNumber(other));}
1908     /**
1909      * <p>Subtracts the second operand from the first operand, resembling the modulo 
1910      * operator in JavaScript.</p>
1911      * <p>If used with non-numeric operands, this operation attempts to convert them to 
1912      * numbers.</p>
1913      * @param var Any numeric value.
1914      * @param other Any numeric value.
1915      * @return The difference between the operands.
1916      * @since 1.0
1917      * @javascript Re-compilers must replace the static invocation of this method with the 
1918      * JavaScript expression:
1919      * <pre>var - other</pre>
1920      */
1921     public static final Number sub(Object var, Object other) { return s().add(s().getNumber(var), neg(other));}
1922     private static final String cat(Object var, Object other) {
1923         return Js.toString(var).concat(Js.toString(other));
1924     }
1925     /**
1926      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
1927      * operator in JavaScript.</p>
1928      * <p>If one operand is a string, the other is converted to a string, and the two 
1929      * strings are then concatenated. Object operands are converted to numbers or strings 
1930      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
1931      * method and/or the {@link #toString(Object)} method on the object.</p>
1932      * @param var A value or object.
1933      * @param other A value or object.
1934      * @return The sum or concatenation of the values.
1935      * @since 1.0
1936      * @javascript Re-compilers must replace the static invocation of this method with the 
1937      * JavaScript expression:
1938      * <pre>var + other</pre>
1939      */
1940     public static final Object add(Object var, Object other) {
1941         Number n1 = s().getNumber(var);
1942         if (n1 == null) {
1943             return Js.toString(var).concat(Js.toString(other));
1944         } else {
1945             Number n2 = s().getNumber(other);
1946             if (n2 == null) {
1947                 return cat(var, other);
1948             } else {
1949                 return s().add(n1, n2);
1950             }
1951         }
1952     }
1953     /**
1954      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
1955      * operator in JavaScript.</p>
1956      * <p>If one operand is a string, the other is converted to a string, and the two 
1957      * strings are then concatenated. Object operands are converted to numbers or strings 
1958      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
1959      * method and/or the {@link #toString(Object)} method on the object.</p>
1960      * @param var A value or object.
1961      * @param other A value or object.
1962      * @return The sum or concatenation of the values.
1963      * @since 1.0
1964      * @javascript Re-compilers must replace the static invocation of this method with the 
1965      * JavaScript expression:
1966      * <pre>var + other</pre>
1967      */
1968     public static final String add(Object var, String other) { return cat(var, other);}
1969     /**
1970      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
1971      * operator in JavaScript.</p>
1972      * <p>If one operand is a string, the other is converted to a string, and the two 
1973      * strings are then concatenated. Object operands are converted to numbers or strings 
1974      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
1975      * method and/or the {@link #toString(Object)} method on the object.</p>
1976      * @param var A value or object.
1977      * @param other A value or object.
1978      * @return The sum or concatenation of the values.
1979      * @since 1.0
1980      * @javascript Re-compilers must replace the static invocation of this method with the 
1981      * JavaScript expression:
1982      * <pre>var + other</pre>
1983      */
1984     public static final String add(Object var, StringLike other) { return cat(var, other);}
1985     /**
1986      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
1987      * operator in JavaScript.</p>
1988      * <p>If one operand is a string, the other is converted to a string, and the two 
1989      * strings are then concatenated. Object operands are converted to numbers or strings 
1990      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
1991      * method and/or the {@link #toString(Object)} method on the object.</p>
1992      * @param var A value or object.
1993      * @param other A value or object.
1994      * @return The sum or concatenation of the values.
1995      * @since 1.0
1996      * @javascript Re-compilers must replace the static invocation of this method with the 
1997      * JavaScript expression:
1998      * <pre>var + other</pre>
1999      */
2000     public static final String add(String var, Object other) { return cat(var, other);}
2001     /**
2002      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2003      * operator in JavaScript.</p>
2004      * <p>If one operand is a string, the other is converted to a string, and the two 
2005      * strings are then concatenated. Object operands are converted to numbers or strings 
2006      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2007      * method and/or the {@link #toString(Object)} method on the object.</p>
2008      * @param var A value or object.
2009      * @param other A value or object.
2010      * @return The sum or concatenation of the values.
2011      * @since 1.0
2012      * @javascript Re-compilers must replace the static invocation of this method with the 
2013      * JavaScript expression:
2014      * <pre>var + other</pre>
2015      */
2016     public static final String add(String var, String other) { return cat(var, other);}
2017     /**
2018      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2019      * operator in JavaScript.</p>
2020      * <p>If one operand is a string, the other is converted to a string, and the two 
2021      * strings are then concatenated. Object operands are converted to numbers or strings 
2022      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2023      * method and/or the {@link #toString(Object)} method on the object.</p>
2024      * @param var A value or object.
2025      * @param other A value or object.
2026      * @return The sum or concatenation of the values.
2027      * @since 1.0
2028      * @javascript Re-compilers must replace the static invocation of this method with the 
2029      * JavaScript expression:
2030      * <pre>var + other</pre>
2031      */
2032     public static final String add(String var, StringLike other) { return cat(var, other);}
2033     /**
2034      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2035      * operator in JavaScript.</p>
2036      * <p>If one operand is a string, the other is converted to a string, and the two 
2037      * strings are then concatenated. Object operands are converted to numbers or strings 
2038      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2039      * method and/or the {@link #toString(Object)} method on the object.</p>
2040      * @param var A value or object.
2041      * @param other A value or object.
2042      * @return The sum or concatenation of the values.
2043      * @since 1.0
2044      * @javascript Re-compilers must replace the static invocation of this method with the 
2045      * JavaScript expression:
2046      * <pre>var + other</pre>
2047      */
2048     public static final String add(StringLike var, Object other) { return cat(var, other);}
2049     /**
2050      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2051      * operator in JavaScript.</p>
2052      * <p>If one operand is a string, the other is converted to a string, and the two 
2053      * strings are then concatenated. Object operands are converted to numbers or strings 
2054      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2055      * method and/or the {@link #toString(Object)} method on the object.</p>
2056      * @param var A value or object.
2057      * @param other A value or object.
2058      * @return The sum or concatenation of the values.
2059      * @since 1.0
2060      * @javascript Re-compilers must replace the static invocation of this method with the 
2061      * JavaScript expression:
2062      * <pre>var + other</pre>
2063      */
2064     public static final String add(StringLike var, String other) { return cat(var, other);}
2065     /**
2066      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2067      * operator in JavaScript.</p>
2068      * <p>If one operand is a string, the other is converted to a string, and the two 
2069      * strings are then concatenated. Object operands are converted to numbers or strings 
2070      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2071      * method and/or the {@link #toString(Object)} method on the object.</p>
2072      * @param var A value or object.
2073      * @param other A value or object.
2074      * @return The sum or concatenation of the values.
2075      * @since 1.0
2076      * @javascript Re-compilers must replace the static invocation of this method with the 
2077      * JavaScript expression:
2078      * <pre>var + other</pre>
2079      */
2080     public static final String add(StringLike var, StringLike other) { return cat(var, other);}
2081     /**
2082      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2083      * operator in JavaScript.</p>
2084      * <p>If one operand is a string, the other is converted to a string, and the two 
2085      * strings are then concatenated. Object operands are converted to numbers or strings 
2086      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2087      * method and/or the {@link #toString(Object)} method on the object.</p>
2088      * @param var A value or object.
2089      * @param other A value or object.
2090      * @return The sum or concatenation of the values.
2091      * @since 1.0
2092      * @javascript Re-compilers must replace the static invocation of this method with the 
2093      * JavaScript expression:
2094      * <pre>var + other</pre>
2095      */
2096     public static final Number add(Character var, Character other) { return s().add(valueOf(var), valueOf(other));}
2097     /**
2098      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2099      * operator in JavaScript.</p>
2100      * <p>If one operand is a string, the other is converted to a string, and the two 
2101      * strings are then concatenated. Object operands are converted to numbers or strings 
2102      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2103      * method and/or the {@link #toString(Object)} method on the object.</p>
2104      * @param var A value or object.
2105      * @param other A value or object.
2106      * @return The sum or concatenation of the values.
2107      * @since 1.0
2108      * @javascript Re-compilers must replace the static invocation of this method with the 
2109      * JavaScript expression:
2110      * <pre>var + other</pre>
2111      */
2112     public static final Number add(Character var, Var<Character> other) { return s().add(valueOf(var), valueOf(other.var()));}
2113     /**
2114      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2115      * operator in JavaScript.</p>
2116      * <p>If one operand is a string, the other is converted to a string, and the two 
2117      * strings are then concatenated. Object operands are converted to numbers or strings 
2118      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2119      * method and/or the {@link #toString(Object)} method on the object.</p>
2120      * @param var A value or object.
2121      * @param other A value or object.
2122      * @return The sum or concatenation of the values.
2123      * @since 1.0
2124      * @javascript Re-compilers must replace the static invocation of this method with the 
2125      * JavaScript expression:
2126      * <pre>var + other</pre>
2127      */
2128     public static final Number add(Character var, Number other) { return s().add(valueOf(var), other);}
2129     /**
2130      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2131      * operator in JavaScript.</p>
2132      * <p>If one operand is a string, the other is converted to a string, and the two 
2133      * strings are then concatenated. Object operands are converted to numbers or strings 
2134      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2135      * method and/or the {@link #toString(Object)} method on the object.</p>
2136      * @param var A value or object.
2137      * @param other A value or object.
2138      * @return The sum or concatenation of the values.
2139      * @since 1.0
2140      * @javascript Re-compilers must replace the static invocation of this method with the 
2141      * JavaScript expression:
2142      * <pre>var + other</pre>
2143      */
2144     public static final Number add(Character var, NumberLike<? extends Number> other) { return s().add(valueOf(var), valueOf(other));}
2145     /**
2146      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2147      * operator in JavaScript.</p>
2148      * <p>If one operand is a string, the other is converted to a string, and the two 
2149      * strings are then concatenated. Object operands are converted to numbers or strings 
2150      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2151      * method and/or the {@link #toString(Object)} method on the object.</p>
2152      * @param var A value or object.
2153      * @param other A value or object.
2154      * @return The sum or concatenation of the values.
2155      * @since 1.0
2156      * @javascript Re-compilers must replace the static invocation of this method with the 
2157      * JavaScript expression:
2158      * <pre>var + other</pre>
2159      */
2160     public static final Number add(Var<Character> var, Character other) { return s().add(valueOf(var.var()), valueOf(other));}
2161     /**
2162      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2163      * operator in JavaScript.</p>
2164      * <p>If one operand is a string, the other is converted to a string, and the two 
2165      * strings are then concatenated. Object operands are converted to numbers or strings 
2166      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2167      * method and/or the {@link #toString(Object)} method on the object.</p>
2168      * @param var A value or object.
2169      * @param other A value or object.
2170      * @return The sum or concatenation of the values.
2171      * @since 1.0
2172      * @javascript Re-compilers must replace the static invocation of this method with the 
2173      * JavaScript expression:
2174      * <pre>var + other</pre>
2175      */
2176     public static final Number add(Var<Character> var, Var<Character> other) { return s().add(valueOf(var.var()), valueOf(other.var()));}
2177     /**
2178      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2179      * operator in JavaScript.</p>
2180      * <p>If one operand is a string, the other is converted to a string, and the two 
2181      * strings are then concatenated. Object operands are converted to numbers or strings 
2182      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2183      * method and/or the {@link #toString(Object)} method on the object.</p>
2184      * @param var A value or object.
2185      * @param other A value or object.
2186      * @return The sum or concatenation of the values.
2187      * @since 1.0
2188      * @javascript Re-compilers must replace the static invocation of this method with the 
2189      * JavaScript expression:
2190      * <pre>var + other</pre>
2191      */
2192     public static final Number add(Var<Character> var, Number other) { return s().add(valueOf(var.var()), other);}
2193     /**
2194      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2195      * operator in JavaScript.</p>
2196      * <p>If one operand is a string, the other is converted to a string, and the two 
2197      * strings are then concatenated. Object operands are converted to numbers or strings 
2198      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2199      * method and/or the {@link #toString(Object)} method on the object.</p>
2200      * @param var A value or object.
2201      * @param other A value or object.
2202      * @return The sum or concatenation of the values.
2203      * @since 1.0
2204      * @javascript Re-compilers must replace the static invocation of this method with the 
2205      * JavaScript expression:
2206      * <pre>var + other</pre>
2207      */
2208     public static final Number add(Var<Character> var, NumberLike<? extends Number> other) { return s().add(valueOf(var.var()), valueOf(other));}
2209     /**
2210      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2211      * operator in JavaScript.</p>
2212      * <p>If one operand is a string, the other is converted to a string, and the two 
2213      * strings are then concatenated. Object operands are converted to numbers or strings 
2214      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2215      * method and/or the {@link #toString(Object)} method on the object.</p>
2216      * @param var A value or object.
2217      * @param other A value or object.
2218      * @return The sum or concatenation of the values.
2219      * @since 1.0
2220      * @javascript Re-compilers must replace the static invocation of this method with the 
2221      * JavaScript expression:
2222      * <pre>var + other</pre>
2223      */
2224     public static final Number add(Number var, Character other) { return s().add(var, valueOf(other));}
2225     /**
2226      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2227      * operator in JavaScript.</p>
2228      * <p>If one operand is a string, the other is converted to a string, and the two 
2229      * strings are then concatenated. Object operands are converted to numbers or strings 
2230      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2231      * method and/or the {@link #toString(Object)} method on the object.</p>
2232      * @param var A value or object.
2233      * @param other A value or object.
2234      * @return The sum or concatenation of the values.
2235      * @since 1.0
2236      * @javascript Re-compilers must replace the static invocation of this method with the 
2237      * JavaScript expression:
2238      * <pre>var + other</pre>
2239      */
2240     public static final Number add(Number var, Var<Character> other) { return s().add(var, valueOf(other.var()));}
2241     /**
2242      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2243      * operator in JavaScript.</p>
2244      * <p>If one operand is a string, the other is converted to a string, and the two 
2245      * strings are then concatenated. Object operands are converted to numbers or strings 
2246      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2247      * method and/or the {@link #toString(Object)} method on the object.</p>
2248      * @param var A value or object.
2249      * @param other A value or object.
2250      * @return The sum or concatenation of the values.
2251      * @since 1.0
2252      * @javascript Re-compilers must replace the static invocation of this method with the 
2253      * JavaScript expression:
2254      * <pre>var + other</pre>
2255      */
2256     public static final Number add(Number var, Number other) { return s().add(var, other);}
2257     /**
2258      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2259      * operator in JavaScript.</p>
2260      * <p>If one operand is a string, the other is converted to a string, and the two 
2261      * strings are then concatenated. Object operands are converted to numbers or strings 
2262      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2263      * method and/or the {@link #toString(Object)} method on the object.</p>
2264      * @param var A value or object.
2265      * @param other A value or object.
2266      * @return The sum or concatenation of the values.
2267      * @since 1.0
2268      * @javascript Re-compilers must replace the static invocation of this method with the 
2269      * JavaScript expression:
2270      * <pre>var + other</pre>
2271      */
2272     public static final Number add(Number var, NumberLike<? extends Number> other) { return s().add(var, valueOf(other));}
2273     /**
2274      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2275      * operator in JavaScript.</p>
2276      * <p>If one operand is a string, the other is converted to a string, and the two 
2277      * strings are then concatenated. Object operands are converted to numbers or strings 
2278      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2279      * method and/or the {@link #toString(Object)} method on the object.</p>
2280      * @param var A value or object.
2281      * @param other A value or object.
2282      * @return The sum or concatenation of the values.
2283      * @since 1.0
2284      * @javascript Re-compilers must replace the static invocation of this method with the 
2285      * JavaScript expression:
2286      * <pre>var + other</pre>
2287      */
2288     public static final Number add(NumberLike<? extends Number> var, Character other) { return s().add(valueOf(var), valueOf(other));}
2289     /**
2290      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2291      * operator in JavaScript.</p>
2292      * <p>If one operand is a string, the other is converted to a string, and the two 
2293      * strings are then concatenated. Object operands are converted to numbers or strings 
2294      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2295      * method and/or the {@link #toString(Object)} method on the object.</p>
2296      * @param var A value or object.
2297      * @param other A value or object.
2298      * @return The sum or concatenation of the values.
2299      * @since 1.0
2300      * @javascript Re-compilers must replace the static invocation of this method with the 
2301      * JavaScript expression:
2302      * <pre>var + other</pre>
2303      */
2304     public static final Number add(NumberLike<? extends Number> var, Var<Character> other) { return s().add(valueOf(var), valueOf(other.var()));}
2305     /**
2306      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2307      * operator in JavaScript.</p>
2308      * <p>If one operand is a string, the other is converted to a string, and the two 
2309      * strings are then concatenated. Object operands are converted to numbers or strings 
2310      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2311      * method and/or the {@link #toString(Object)} method on the object.</p>
2312      * @param var A value or object.
2313      * @param other A value or object.
2314      * @return The sum or concatenation of the values.
2315      * @since 1.0
2316      * @javascript Re-compilers must replace the static invocation of this method with the 
2317      * JavaScript expression:
2318      * <pre>var + other</pre>
2319      */
2320     public static final Number add(NumberLike<? extends Number> var, Number other) { return s().add(valueOf(var), other);}
2321     /**
2322      * <p>Adds numeric operands or concatenates string operands, resembling the addition 
2323      * operator in JavaScript.</p>
2324      * <p>If one operand is a string, the other is converted to a string, and the two 
2325      * strings are then concatenated. Object operands are converted to numbers or strings 
2326      * that can be added or concatenated. The conversion is performed by {@link #valueOf(Object)}  
2327      * method and/or the {@link #toString(Object)} method on the object.</p>
2328      * @param var A value or object.
2329      * @param other A value or object.
2330      * @return The sum or concatenation of the values.
2331      * @since 1.0
2332      * @javascript Re-compilers must replace the static invocation of this method with the 
2333      * JavaScript expression:
2334      * <pre>var + other</pre>
2335      */
2336     public static final Number add(NumberLike<? extends Number> var, NumberLike<? extends Number> other) { return s().add(valueOf(var), valueOf(other));}
2337 
2338     /**
2339      * <p>Checks if the first operand is the name of a property of the second, resembling 
2340      * the <tt>in</tt> operator in JavaScript.</p>
2341      * <p>This operation converts the first operand to a string and expects the second 
2342      * operand be an object (or array).</p>
2343      * @param var Any value that is or can be converted to a string.
2344      * @param other Any object or array.
2345      * @return <tt>true</tt> if the first operand is the name of a property of the 
2346      * second operand; <tt>false</tt>, otherwise;
2347      * @since 1.0
2348      * @javascript Re-compilers must replace the static invocation of this method with the 
2349      * JavaScript expression:
2350      * <pre>var in other</pre>
2351      */
2352     public static final boolean in(Object var, Object other) { return s().in(var, other);}
2353     /**
2354      * <p>Checks if the first operand is an instance of the second, resembling the 
2355      * <tt>instanceof</tt> operator in JavaScript.</p>
2356      * <p>This operation expects the first operand be an object and the second be a class 
2357      * of objects. In JavaScript, classes of objects are defined by the constructor function 
2358      * that initializes them.</p>
2359      * @param var Any value or object.
2360      * @param other A constructor function.
2361      * @return <tt>true</tt> if the first operand is an instance of the second; 
2362      * <tt>false</tt>, otherwise;
2363      * @since 1.0
2364      * @javascript Re-compilers must replace the static invocation of this method with the 
2365      * JavaScript expression:
2366      * <pre>var instanceof other</pre>
2367      */
2368     public static final boolean instanceOf(Object var, Object other) { return s().instanceOf(var, other);}
2369 
2370     /**
2371      * <p>Shift-left operation, resembling that of JavaScript, moves all bits in the first 
2372      * operand to the left by the number of places specified in the second operand, which 
2373      * should be an integer between 0 and 31.</p>
2374      * <p>A zero is used for the new first bit, and the value of the 32nd bit is lost. 
2375      * Shifting a value left by one position is equivalent to multiplying by 2, shifting 
2376      * two positions is equivalent to multiplying by 4, etc.</p>
2377      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2378      * operation requires numeric operands that have integer values. It operate on the integer 
2379      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2380      * representation.</p>
2381      * <p>If this bitwise operation is used with operands that are not integers or are too 
2382      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2383      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2384      * the 32nd. The shift operation requires a right-side operand between 0 and 31. After 
2385      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2386      * yields a number in the appropriate range.</p>
2387      * @param var A numeric value.
2388      * @param n The number of bits to shift.
2389      * @return The shifted integer number.
2390      * @since 1.0
2391      * @javascript Re-compilers must replace the static invocation of this method with the 
2392      * JavaScript expression:
2393      * <pre>var << n</pre>
2394      */
2395     public static final int shl (Object var, int n) { return s().getNumber(var).intValue() << n;}
2396     /**
2397      * <p>Shift-right operation, resembling that of JavaScript, moves all bits in the first 
2398      * operand to the right by the number of places specified in the second operand (an 
2399      * integer between 0 and 31). Bits that are shifted off the right are lost. The bits 
2400      * filled in on the left depend on the sign bit of the original operand, in order to 
2401      * preserve the sign of the result. If the first operand is positive, the result has 
2402      * zeros placed in the high bits; if the first operand is negative, the result has ones 
2403      * placed in the high bits.</p>
2404      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
2405      * remainder), shifting right two places is equivalent to integer division by 4, and 
2406      * so on.</p>
2407      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2408      * operation requires numeric operands that have integer values. It operate on the integer 
2409      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2410      * representation.</p>
2411      * <p>If this bitwise operation is used with operands that are not integers or are too 
2412      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2413      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2414      * the 32nd. The shift operation requires a right-side operand between 0 and 31. After 
2415      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2416      * yields a number in the appropriate range.</p>
2417      * @param var A numeric value.
2418      * @param n The number of bits to shift.
2419      * @return The shifted integer number.
2420      * @since 1.0
2421      * @javascript Re-compilers must replace the static invocation of this method with the 
2422      * JavaScript expression:
2423      * <pre>var >> n</pre>
2424      */
2425     public static final int shr (Object var, int n) { return s().getNumber(var).intValue() >> n;}
2426     /**
2427      * <p>Shift-right-unsigned operation, resembling that of JavaScript, moves all bits in 
2428      * the first operand to the right by the number of places specified in the second 
2429      * operand (an integer between 0 and 31). Bits that are shifted off the right are lost. 
2430      * The result has zeros placed in the high bits.</p>
2431      * <p>This operation is just like {@link #shr(Object, int)}, except that the bits shifted 
2432      * in on the left are always zero, regardless of the sign of the first operand.</p>
2433      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
2434      * remainder), shifting right two places is equivalent to integer division by 4, and 
2435      * so on.</p>
2436      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2437      * operation requires numeric operands that have integer values. It operate on the integer 
2438      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2439      * representation.</p>
2440      * <p>If this bitwise operation is used with operands that are not integers or are too 
2441      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2442      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2443      * the 32nd. The shift operation requires a right-side operand between 0 and 31. After 
2444      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2445      * yields a number in the appropriate range.</p>
2446      * @param var A numeric value.
2447      * @param n The number of bits to shift.
2448      * @return The shifted integer number.
2449      * @since 1.0
2450      * @javascript Re-compilers must replace the static invocation of this method with the 
2451      * JavaScript expression:
2452      * <pre>var >>> n</pre>
2453      */
2454     public static final int shru(Object var, int n) { return s().getNumber(var).intValue() >>> n;}
2455     /**
2456      * <p>Bitwise-NOT operation, resembling that of JavaScript, operates by reversing all 
2457      * bits in the operand.</p>
2458      * <p>Because of the way signed integers are represented in JavaScript, applying this 
2459      * operation to a value is equivalent to changing its sign and subtracting 1.</p>
2460      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2461      * operation requires numeric operands that have integer values. It operate on the integer 
2462      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2463      * representation.</p>
2464      * <p>If this bitwise operation is used with operands that are not integers or are too 
2465      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2466      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2467      * the 32nd.</p>
2468      * @param var A numeric value.
2469      * @return The bitwise-NOT of the operand.
2470      * @since 1.0
2471      * @javascript Re-compilers must replace the static invocation of this method with the 
2472      * JavaScript expression:
2473      * <pre>~var</pre>
2474      */
2475     public static final int bnot(Object var) { return ~s().getNumber(var).intValue();}
2476     /**
2477      * <p>Bitwise-AND operation, resembling that of JavaScript, performs a boolean AND 
2478      * operation on each bit of the integer arguments. A bit is set in the result only if 
2479      * the corresponding bit is set in both operands.</p>
2480      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2481      * operation requires numeric operands that have integer values. It operate on the integer 
2482      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2483      * representation.</p>
2484      * <p>If this bitwise operation is used with operands that are not integers or are too 
2485      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2486      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2487      * the 32nd.</p>
2488      * @param var A numeric value.
2489      * @param other A numeric value.
2490      * @return The bitwise-AND of the two operands.
2491      * @since 1.0
2492      * @javascript Re-compilers must replace the static invocation of this method with the 
2493      * JavaScript expression:
2494      * <pre>var & other</pre>
2495      */
2496     public static final int band(Object var, Object other) { return s().getNumber(var).intValue() & s().getNumber(other).intValue();}
2497     /**
2498      * <p>Bitwise-OR operation, resembling that of JavaScript, performs a boolean OR operation 
2499      * on each bit of the integer arguments. A bit is set in the result if the corresponding 
2500      * bit is set in one or both of the operands.</p>
2501      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2502      * operation requires numeric operands that have integer values. It operate on the integer 
2503      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2504      * representation.</p>
2505      * <p>If this bitwise operation is used with operands that are not integers or are too 
2506      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2507      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2508      * the 32nd.</p>
2509      * @param var A numeric value.
2510      * @param other A numeric value.
2511      * @return The bitwise-OR of the two operands.
2512      * @since 1.0
2513      * @javascript Re-compilers must replace the static invocation of this method with the 
2514      * JavaScript expression:
2515      * <pre>var | other</pre>
2516      */
2517     public static final int bor (Object var, Object other) { return s().getNumber(var).intValue() | s().getNumber(other).intValue();}
2518     /**
2519      * <p>Bitwise-XOR operation, resembling that of JavaScript, performs a boolean exclusive 
2520      * OR operation on each bit of the integer arguments. Exclusive OR means that either 
2521      * operand one is <tt>true</tt> or operand two is <tt>true</tt>, but not both. A bit is 
2522      * set in this operation's result if a corresponding bit is set in one (but not both) 
2523      * of the two operands.</p>
2524      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2525      * operation requires numeric operands that have integer values. It operate on the integer 
2526      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2527      * representation.</p>
2528      * <p>If this bitwise operation is used with operands that are not integers or are too 
2529      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2530      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2531      * the 32nd.</p>
2532      * @param var A numeric value.
2533      * @param other A numeric value.
2534      * @return The bitwise-exclusive-OR of the two operands.
2535      * @since 1.0
2536      * @javascript Re-compilers must replace the static invocation of this method with the 
2537      * JavaScript expression:
2538      * <pre>var ^ other</pre>
2539      */
2540     public static final int xor (Object var, Object other) { return s().getNumber(var).intValue() ^ s().getNumber(other).intValue();}
2541 
2542     /**
2543      * <p>Less-than operation, resembling that of JavaScript, evaluates to <tt>true</tt> if 
2544      * the first operand is less than the second operand; otherwise it evaluates to 
2545      * <tt>false</tt>.</p>
2546      * <p>The operands of this operation may be of any type. Comparison can be performed 
2547      * only on numbers and strings, however, so operands that are not numbers or strings 
2548      * are converted. Comparison and conversion occur as follows:</p>
2549      * <ul>
2550      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2551      * numerically.</li>
2552      * <li>If both operands are strings or convert to strings, they are compared as 
2553      * strings.</li>
2554      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2555      * the operation attempts to convert the string to a number and performs a numerical 
2556      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2557      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2558      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2559      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2560      * the numerical conversion. This means, for example, that Date objects are compared 
2561      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2562      * than the other.</li>
2563      * <li>If the operands of the comparison operations cannot both be successfully converted 
2564      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2565      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2566      * yields <tt>false</tt>.</li>
2567      * </ul>
2568      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2569      * basis using the numerical value of each character from the Unicode encoding. Although 
2570      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2571      * different sequences of characters, the JavaScript comparison operations do not 
2572      * detect these encoding differences; they assume that all strings are expressed in 
2573      * normalized form. Note in particular that string comparison is case-sensitive, and 
2574      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2575      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2576      * not expect it.</p>
2577      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2578      * method, which also takes locale-specific definitions of alphabetical order into account. 
2579      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2580      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2581      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2582      * equality or identity operations for determining whether two values are "equal." 
2583      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2584      * and the greater-than-or-equal operator is defined as "not less than". The one 
2585      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2586      * all comparison operations return <tt>false</tt>.</p>
2587      * @param var A value or object.
2588      * @param other A value or object.
2589      * @return <tt>true</tt> if the first operand is less than the second operand; 
2590      * otherwise <tt>false</tt>.
2591      * @since 1.0
2592      * @javascript Re-compilers must replace the static invocation of this method with the 
2593      * JavaScript expression:
2594      * <pre>var < other</pre>
2595      */
2596     public static final boolean lt (Object var, Object other) { return s().lt(var, other);}
2597     /**
2598      * <p>Greater-than operation, resembling that of JavaScript, evaluates to <tt>true</tt> if 
2599      * the first operand is greater than the second operand; otherwise it evaluates to 
2600      * <tt>false</tt>.</p>
2601      * <p>The operands of this operation may be of any type. Comparison can be performed 
2602      * only on numbers and strings, however, so operands that are not numbers or strings 
2603      * are converted. Comparison and conversion occur as follows:</p>
2604      * <ul>
2605      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2606      * numerically.</li>
2607      * <li>If both operands are strings or convert to strings, they are compared as 
2608      * strings.</li>
2609      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2610      * the operation attempts to convert the string to a number and performs a numerical 
2611      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2612      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2613      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2614      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2615      * the numerical conversion. This means, for example, that Date objects are compared 
2616      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2617      * than the other.</li>
2618      * <li>If the operands of the comparison operations cannot both be successfully converted 
2619      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2620      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2621      * yields <tt>false</tt>.</li>
2622      * </ul>
2623      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2624      * basis using the numerical value of each character from the Unicode encoding. Although 
2625      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2626      * different sequences of characters, the JavaScript comparison operations do not 
2627      * detect these encoding differences; they assume that all strings are expressed in 
2628      * normalized form. Note in particular that string comparison is case-sensitive, and 
2629      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2630      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2631      * not expect it.</p>
2632      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2633      * method, which also takes locale-specific definitions of alphabetical order into account. 
2634      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2635      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2636      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2637      * equality or identity operations for determining whether two values are "equal." 
2638      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2639      * and the greater-than-or-equal operator is defined as "not less than". The one 
2640      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2641      * all comparison operations return <tt>false</tt>.</p>
2642      * @param var A value or object.
2643      * @param other A value or object.
2644      * @return <tt>true</tt> if the first operand is greater than the second operand; 
2645      * otherwise <tt>false</tt>.
2646      * @since 1.0
2647      * @javascript Re-compilers must replace the static invocation of this method with the 
2648      * JavaScript expression:
2649      * <pre>var > other</pre>
2650      */
2651     public static final boolean gt (Object var, Object other) { return s().gt(var, other);}
2652     /**
2653      * <p>Less-than-or-equal operation, resembling that of JavaScript, evaluates to 
2654      * <tt>true</tt> if the first operand is less than or equal to the second operand; 
2655      * otherwise it evaluates to <tt>false</tt>.</p>
2656      * <p>The operands of this operation may be of any type. Comparison can be performed 
2657      * only on numbers and strings, however, so operands that are not numbers or strings 
2658      * are converted. Comparison and conversion occur as follows:</p>
2659      * <ul>
2660      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2661      * numerically.</li>
2662      * <li>If both operands are strings or convert to strings, they are compared as 
2663      * strings.</li>
2664      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2665      * the operation attempts to convert the string to a number and performs a numerical 
2666      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2667      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2668      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2669      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2670      * the numerical conversion. This means, for example, that Date objects are compared 
2671      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2672      * than the other.</li>
2673      * <li>If the operands of the comparison operations cannot both be successfully converted 
2674      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2675      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2676      * yields <tt>false</tt>.</li>
2677      * </ul>
2678      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2679      * basis using the numerical value of each character from the Unicode encoding. Although 
2680      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2681      * different sequences of characters, the JavaScript comparison operations do not 
2682      * detect these encoding differences; they assume that all strings are expressed in 
2683      * normalized form. Note in particular that string comparison is case-sensitive, and 
2684      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2685      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2686      * not expect it.</p>
2687      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2688      * method, which also takes locale-specific definitions of alphabetical order into account. 
2689      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2690      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2691      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2692      * equality or identity operations for determining whether two values are "equal." 
2693      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2694      * and the greater-than-or-equal operator is defined as "not less than". The one 
2695      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2696      * all comparison operations return <tt>false</tt>.</p>
2697      * @param var A value or object.
2698      * @param other A value or object.
2699      * @return <tt>true</tt> if the first operand is less than or equal to the second operand; 
2700      * otherwise <tt>false</tt>.
2701      * @since 1.0
2702      * @javascript Re-compilers must replace the static invocation of this method with the 
2703      * JavaScript expression:
2704      * <pre>var <= other</pre>
2705      */
2706     public static final boolean lte(Object var, Object other) { return s().lte(var, other);}
2707     /**
2708      * <p>Greater-than-or-equal operation, resembling that of JavaScript, evaluates to 
2709      * <tt>true</tt> if the first operand is greater than or equal to the second operand; 
2710      * otherwise it evaluates to <tt>false</tt>.</p>
2711      * <p>The operands of this operation may be of any type. Comparison can be performed 
2712      * only on numbers and strings, however, so operands that are not numbers or strings 
2713      * are converted. Comparison and conversion occur as follows:</p>
2714      * <ul>
2715      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2716      * numerically.</li>
2717      * <li>If both operands are strings or convert to strings, they are compared as 
2718      * strings.</li>
2719      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2720      * the operation attempts to convert the string to a number and performs a numerical 
2721      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2722      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2723      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2724      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2725      * the numerical conversion. This means, for example, that Date objects are compared 
2726      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2727      * than the other.</li>
2728      * <li>If the operands of the comparison operations cannot both be successfully converted 
2729      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2730      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2731      * yields <tt>false</tt>.</li>
2732      * </ul>
2733      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2734      * basis using the numerical value of each character from the Unicode encoding. Although 
2735      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2736      * different sequences of characters, the JavaScript comparison operations do not 
2737      * detect these encoding differences; they assume that all strings are expressed in 
2738      * normalized form. Note in particular that string comparison is case-sensitive, and 
2739      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2740      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2741      * not expect it.</p>
2742      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2743      * method, which also takes locale-specific definitions of alphabetical order into account. 
2744      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2745      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2746      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2747      * equality or identity operations for determining whether two values are "equal." 
2748      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2749      * and the greater-than-or-equal operator is defined as "not less than". The one 
2750      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2751      * all comparison operations return <tt>false</tt>.</p>
2752      * @param var A value or object.
2753      * @param other A value or object.
2754      * @return <tt>true</tt> if the first operand is greater than or equal to the second operand; 
2755      * otherwise <tt>false</tt>.
2756      * @since 1.0
2757      * @javascript Re-compilers must replace the static invocation of this method with the 
2758      * JavaScript expression:
2759      * <pre>var >= other</pre>
2760      */
2761     public static final boolean gte(Object var, Object other) { return s().gte(var, other);}
2762     /**
2763      * <p>Checks whether the two operands are "equal" using a more relaxed definition of 
2764      * sameness that allows type conversions, resembling the equality operator in 
2765      * JavaScript.</p>
2766      * <p>The equality and identity operations check whether two values are the same, using 
2767      * two different definitions of sameness. Both operations accept operands of any type, 
2768      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2769      * if they are different. The identity operation checks whether its two operands are 
2770      * "identical" using a strict definition of sameness. The equality operation checks 
2771      * whether its two operands are "equal" using a more relaxed definition of sameness 
2772      * that allows type conversions.</p>
2773      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2774      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2775      * assignment, equality, and identity operations, and be careful to use the correct one 
2776      * when coding! Although it is tempting to call all three operations "equals," it may 
2777      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2778      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2779      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2780      * case, two separate values are involved, and the equality and identity operations 
2781      * check that these two values are identical. This means that two variables are equal 
2782      * or identical only if they contain the same value. For example, two strings are equal 
2783      * only if they each contain exactly the same characters.</p>
2784      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2785      * means that two variables are equal only if they refer to the same object. Two 
2786      * separate arrays are never equal or identical, even if they contain equal or identical 
2787      * elements. Two variables that contain references to objects, arrays, or functions are 
2788      * equal only if they refer to the same object, array, or function. If you want to test 
2789      * that two distinct objects contain the same properties or that two distinct arrays 
2790      * contain the same elements, you'll have to check the properties or elements individually 
2791      * for equality or identity. And, if any of the properties or elements are themselves 
2792      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2793      * <p>The following rules determine whether two values are equal according to the 
2794      * equality operation:
2795      * <ul>
2796      * <li>If the two values have the same type, test them for identity. If the values are 
2797      * identical, they are equal; if they are not identical, they are not equal.</li>
2798      * <li>If the two values do not have the same type, they may still be equal. Use the 
2799      * following rules and type conversions to check for equality:</li>
2800      * <ul>
2801      * <li>If one value is null and the other is undefined, they are equal.</li>
2802      * <li>If one value is a number and the other is a string, convert the string to a 
2803      * number and try the comparison again, using the converted value.</li>
2804      * <li>If either value is <tt>true</tt>, convert it to 1 and try the comparison 
2805      * again. If either value is <tt>false</tt>, convert it to 0 and try the comparison 
2806      * again.</li>
2807      * <li>If one value is an object and the other is a number or string, convert the 
2808      * object to a primitive and try the comparison again. An object is converted to a 
2809      * primitive value by either its <tt>toString()</tt> method or its <tt>valueOf()</tt> 
2810      * method. The built-in classes of core JavaScript attempt <tt>valueOf()</tt> 
2811      * conversion before <tt>toString()</tt> conversion, except for the Date class, 
2812      * which performs <tt>toString()</tt> conversion. Objects that are not part of core 
2813      * JavaScript may convert themselves to primitive values in an implementation-defined 
2814      * way.</li>
2815      * <li>Any other combinations of values are not equal.</li>
2816      * </ul>
2817      * </ul>
2818      * @param var Any value or object.
2819      * @param other Any value or object.
2820      * @return <tt>true</tt> if the first operand equals the second; <tt>false</tt>, 
2821      * otherwise;
2822      * @since 1.0
2823      * @javascript Re-compilers must replace the static invocation of this method with the 
2824      * JavaScript expression:
2825      * <pre>var == other</pre>
2826      */
2827     public static final boolean eq  (Object var, Object other) { return s().eq  (var, other);}
2828     /**
2829      * <p>Checks whether the two operands are "identical" using a strict definition of 
2830      * sameness, resembling the identity operator in JavaScript.</p>
2831      * <p>The equality and identity operations check whether two values are the same, using 
2832      * two different definitions of sameness. Both operations accept operands of any type, 
2833      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2834      * if they are different. The identity operation checks whether its two operands are 
2835      * "identical" using a strict definition of sameness. The equality operation checks 
2836      * whether its two operands are "equal" using a more relaxed definition of sameness 
2837      * that allows type conversions.</p>
2838      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2839      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2840      * assignment, equality, and identity operations, and be careful to use the correct one 
2841      * when coding! Although it is tempting to call all three operations "equals," it may 
2842      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2843      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2844      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2845      * case, two separate values are involved, and the equality and identity operations 
2846      * check that these two values are identical. This means that two variables are equal 
2847      * or identical only if they contain the same value. For example, two strings are equal 
2848      * only if they each contain exactly the same characters.</p>
2849      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2850      * means that two variables are equal only if they refer to the same object. Two 
2851      * separate arrays are never equal or identical, even if they contain equal or identical 
2852      * elements. Two variables that contain references to objects, arrays, or functions are 
2853      * equal only if they refer to the same object, array, or function. If you want to test 
2854      * that two distinct objects contain the same properties or that two distinct arrays 
2855      * contain the same elements, you'll have to check the properties or elements individually 
2856      * for equality or identity. And, if any of the properties or elements are themselves 
2857      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2858      * <p>The following rules determine whether two values are identical according to the identity operation:
2859      * <ul>
2860      * <li>If the two values have different types, they are not identical.</li>
2861      * <li>If both values are numbers and have the same value, they are identical, unless 
2862      * either or both values are <tt>NaN</tt>, in which case they are not identical. 
2863      * The <tt>NaN</tt> value is never identical to any other value, including itself! 
2864      * To check whether a value is <tt>NaN</tt>, use the global {@link Js#isNaN(Object)} 
2865      * function.</li>
2866      * <li>If both values are strings and contain exactly the same characters in the same 
2867      * positions, they are identical. If the strings differ in length or content, they are 
2868      * not identical. Note that in some cases, the Unicode standard allows more than one 
2869      * way to encode the same string. For efficiency, however, JavaScript's string 
2870      * comparison compares strictly on a character-by-character basis, and it assumes that 
2871      * all strings have been converted to a "normalized form" before they are compared. 
2872      * See the {@link StringLike#localeCompare(Object)} for another way to compare strings.</li>
2873      * <li>If both values are the boolean value <tt>true</tt> or both are the boolean 
2874      * value <tt>false</tt>, they are identical.</li>
2875      * <li>If both values refer to the same object, array, or function, they are identical. 
2876      * If they refer to different objects (or arrays or functions) they are not identical, 
2877      * even if both objects have identical properties or both arrays have identical elements.</li>
2878      * <li>If both values are null or both values are undefined, they are identical.</li>
2879      * </ul>
2880      * @param var Any value or object.
2881      * @param other Any value or object.
2882      * @return <tt>true</tt> if the first operand is identical to the second; 
2883      * <tt>false</tt>, otherwise;
2884      * @since 1.0
2885      * @javascript Re-compilers must replace the static invocation of this method with the 
2886      * JavaScript expression:
2887      * <pre>var === other</pre>
2888      */
2889     public static final boolean eqs (Object var, Object other) { return s().eqs (var, other);}
2890     /**
2891      * <p>Checks whether the two operands are not "equal" using a more relaxed definition of 
2892      * sameness that allows type conversions, resembling the equality operator in 
2893      * JavaScript.</p>
2894      * <p>The equality and identity operations check whether two values are the same, using 
2895      * two different definitions of sameness. Both operations accept operands of any type, 
2896      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2897      * if they are different. The identity operation checks whether its two operands are 
2898      * "identical" using a strict definition of sameness. The equality operation checks 
2899      * whether its two operands are "equal" using a more relaxed definition of sameness 
2900      * that allows type conversions.</p>
2901      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2902      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2903      * assignment, equality, and identity operations, and be careful to use the correct one 
2904      * when coding! Although it is tempting to call all three operations "equals," it may 
2905      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2906      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2907      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2908      * case, two separate values are involved, and the equality and identity operations 
2909      * check that these two values are identical. This means that two variables are equal 
2910      * or identical only if they contain the same value. For example, two strings are equal 
2911      * only if they each contain exactly the same characters.</p>
2912      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2913      * means that two variables are equal only if they refer to the same object. Two 
2914      * separate arrays are never equal or identical, even if they contain equal or identical 
2915      * elements. Two variables that contain references to objects, arrays, or functions are 
2916      * equal only if they refer to the same object, array, or function. If you want to test 
2917      * that two distinct objects contain the same properties or that two distinct arrays 
2918      * contain the same elements, you'll have to check the properties or elements individually 
2919      * for equality or identity. And, if any of the properties or elements are themselves 
2920      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2921      * <p>The following rules determine whether two values are equal according to the 
2922      * equality operation:
2923      * <ul>
2924      * <li>If the two values have the same type, test them for identity. If the values are 
2925      * identical, they are equal; if they are not identical, they are not equal.</li>
2926      * <li>If the two values do not have the same type, they may still be equal. Use the 
2927      * following rules and type conversions to check for equality:</li>
2928      * <ul>
2929      * <li>If one value is null and the other is undefined, they are equal.</li>
2930      * <li>If one value is a number and the other is a string, convert the string to a 
2931      * number and try the comparison again, using the converted value.</li>
2932      * <li>If either value is <tt>true</tt>, convert it to 1 and try the comparison 
2933      * again. If either value is <tt>false</tt>, convert it to 0 and try the comparison 
2934      * again.</li>
2935      * <li>If one value is an object and the other is a number or string, convert the 
2936      * object to a primitive and try the comparison again. An object is converted to a 
2937      * primitive value by either its <tt>toString()</tt> method or its <tt>valueOf()</tt> 
2938      * method. The built-in classes of core JavaScript attempt <tt>valueOf()</tt> 
2939      * conversion before <tt>toString()</tt> conversion, except for the Date class, 
2940      * which performs <tt>toString()</tt> conversion. Objects that are not part of core 
2941      * JavaScript may convert themselves to primitive values in an implementation-defined 
2942      * way.</li>
2943      * <li>Any other combinations of values are not equal.</li>
2944      * </ul>
2945      * </ul>
2946      * @param var Any value or object.
2947      * @param other Any value or object.
2948      * @return <tt>false</tt> if the first operand equals the second; <tt>true</tt>, 
2949      * otherwise;
2950      * @since 1.0
2951      * @javascript Re-compilers must replace the static invocation of this method with the 
2952      * JavaScript expression:
2953      * <pre>var != other</pre>
2954      */
2955     public static final boolean neq (Object var, Object other) { return !eq (var, other);}
2956     /**
2957      * <p>Checks whether the two operands are not "identical" using a strict definition of 
2958      * sameness, resembling the identity operator in JavaScript.</p>
2959      * <p>The equality and identity operations check whether two values are the same, using 
2960      * two different definitions of sameness. Both operations accept operands of any type, 
2961      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2962      * if they are different. The identity operation checks whether its two operands are 
2963      * "identical" using a strict definition of sameness. The equality operation checks 
2964      * whether its two operands are "equal" using a more relaxed definition of sameness 
2965      * that allows type conversions.</p>
2966      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2967      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2968      * assignment, equality, and identity operations, and be careful to use the correct one 
2969      * when coding! Although it is tempting to call all three operations "equals," it may 
2970      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2971      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2972      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2973      * case, two separate values are involved, and the equality and identity operations 
2974      * check that these two values are identical. This means that two variables are equal 
2975      * or identical only if they contain the same value. For example, two strings are equal 
2976      * only if they each contain exactly the same characters.</p>
2977      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2978      * means that two variables are equal only if they refer to the same object. Two 
2979      * separate arrays are never equal or identical, even if they contain equal or identical 
2980      * elements. Two variables that contain references to objects, arrays, or functions are 
2981      * equal only if they refer to the same object, array, or function. If you want to test 
2982      * that two distinct objects contain the same properties or that two distinct arrays 
2983      * contain the same elements, you'll have to check the properties or elements individually 
2984      * for equality or identity. And, if any of the properties or elements are themselves 
2985      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2986      * <p>The following rules determine whether two values are identical according to the identity operation:
2987      * <ul>
2988      * <li>If the two values have different types, they are not identical.</li>
2989      * <li>If both values are numbers and have the same value, they are identical, unless 
2990      * either or both values are <tt>NaN</tt>, in which case they are not identical. 
2991      * The <tt>NaN</tt> value is never identical to any other value, including itself! 
2992      * To check whether a value is <tt>NaN</tt>, use the global {@link Js#isNaN(Object)} 
2993      * function.</li>
2994      * <li>If both values are strings and contain exactly the same characters in the same 
2995      * positions, they are identical. If the strings differ in length or content, they are 
2996      * not identical. Note that in some cases, the Unicode standard allows more than one 
2997      * way to encode the same string. For efficiency, however, JavaScript's string 
2998      * comparison compares strictly on a character-by-character basis, and it assumes that 
2999      * all strings have been converted to a "normalized form" before they are compared. 
3000      * See the {@link StringLike#localeCompare(Object)} for another way to compare strings.</li>
3001      * <li>If both values are the boolean value <tt>true</tt> or both are the boolean 
3002      * value <tt>false</tt>, they are identical.</li>
3003      * <li>If both values refer to the same object, array, or function, they are identical. 
3004      * If they refer to different objects (or arrays or functions) they are not identical, 
3005      * even if both objects have identical properties or both arrays have identical elements.</li>
3006      * <li>If both values are null or both values are undefined, they are identical.</li>
3007      * </ul>
3008      * @param var Any value or object.
3009      * @param other Any value or object.
3010      * @return <tt>false</tt> if the first operand is identical to the second; 
3011      * <tt>true</tt>, otherwise;
3012      * @since 1.0
3013      * @javascript Re-compilers must replace the static invocation of this method with the 
3014      * JavaScript expression:
3015      * <pre>var !== other</pre>
3016      */
3017     public static final boolean neqs(Object var, Object other) { return !eqs(var, other);}
3018 
3019     /**
3020      * <p>Inverts the boolean value of its operand, resembling the logical NOT operator 
3021      * in JavaScript.</p>
3022      * <p>This operation converts its operand to a boolean value using the following rules 
3023      * if necessary before inverting the converted value.</p>
3024      * <ul>
3025      * <li>If a number is used where a boolean value is expected, the number is converted 
3026      * to <tt>true</tt> unless the number is 0 or NaN, which are converted to <tt>false</tt>.</li>
3027      * <li>If a string is used where a boolean value is expected, it is converted to <tt>true</tt> 
3028      * except for the empty string, which is converted to <tt>false</tt>.</li>
3029      * <li><tt>null</tt> and the undefined value convert to <tt>false</tt>, and any 
3030      * non-null object, array, or function converts to <tt>true</tt>.
3031      * </ul>
3032      * <p>You can convert any value <tt>x</tt> to its equivalent boolean value by applying 
3033      * this operation twice: <tt>Js.not(Js.not(x))</tt></p>
3034      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3035      * re-compilations. However, in most cases you can use the logical NOT operator of the 
3036      * Java language like this:
3037      * <pre>!Js.be(var)</pre>
3038      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3039      * JavaScript expression since the Java compilers generally used are free to compile 
3040      * the expression into any byte codes they think efficient, making it too hard for the 
3041      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3042      * @param var A value or object.
3043      * @return The inverted boolean value.
3044      * @since 1.0
3045      * @javascript Re-compilers must replace the static invocation of this method with the 
3046      * JavaScript expression:
3047      * <pre>!var</pre>
3048      */
3049     public static final boolean not(Object var) { return !Js.be(var);}
3050 
3051     /**
3052      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3053      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3054      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3055      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3056      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3057      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3058      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3059      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3060      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3061      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3062      * its second operand, the expression on its right, and returns the value of that 
3063      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3064      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3065      * returning the unconverted value of the left-side expression.</p>
3066      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3067      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3068      * anonymously, returning the actual expression in the method overriding 
3069      * {@link Var#var()}.</p>
3070      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3071      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3072      * decrements, and function calls) for the second operand unless you are quite sure 
3073      * you know exactly what you are doing.</p>
3074      * <p>Despite the fairly confusing way that this operation actually works, it is 
3075      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3076      * Although it does not actually return a boolean value, the value it returns can always 
3077      * be converted to a boolean value.</p>
3078      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3079      * re-compilations. However, in most cases you can use the logical AND operator of the 
3080      * Java language like this:
3081      * <pre>Js.be(var) && Js.be(other)</pre>
3082      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3083      * JavaScript expression since the Java compilers generally used are free to compile 
3084      * the expression into any byte codes they think efficient, making it too hard for the 
3085      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3086      * @param var A value or object.
3087      * @param other A value or object.
3088      * @return The logical AND of the two operands.
3089      * @since 1.0
3090      * @javascript Re-compilers must replace the static invocation of this method with the 
3091      * JavaScript expression:
3092      * <pre>var && other</pre>
3093      */
3094     public static final <T> T and(T var, T other) { return not(var) ? var : other;}
3095     /**
3096      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3097      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3098      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3099      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3100      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3101      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3102      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3103      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3104      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3105      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3106      * its second operand, the expression on its right, and returns the value of that 
3107      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3108      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3109      * returning the unconverted value of the left-side expression.</p>
3110      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3111      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3112      * anonymously, returning the actual expression in the method overriding 
3113      * {@link Var#var()}.</p>
3114      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3115      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3116      * decrements, and function calls) for the second operand unless you are quite sure 
3117      * you know exactly what you are doing.</p>
3118      * <p>Despite the fairly confusing way that this operation actually works, it is 
3119      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3120      * Although it does not actually return a boolean value, the value it returns can always 
3121      * be converted to a boolean value.</p>
3122      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3123      * re-compilations. However, in most cases you can use the logical AND operator of the 
3124      * Java language like this:
3125      * <pre>Js.be(var) && Js.be(other)</pre>
3126      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3127      * JavaScript expression since the Java compilers generally used are free to compile 
3128      * the expression into any byte codes they think efficient, making it too hard for the 
3129      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3130      * @param var A value or object.
3131      * @param other A value or object.
3132      * @return The logical AND of the two operands.
3133      * @since 1.0
3134      * @javascript Re-compilers must replace the static invocation of this method with the 
3135      * JavaScript expression:
3136      * <pre>var && other</pre>
3137      */
3138     public static final <T> T and(Var<? extends T> var, T other) {
3139         if (var == null) return (T)null;
3140         T v = var.var();
3141         return not(v) ? v : other;
3142     }
3143     /**
3144      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3145      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3146      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3147      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3148      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3149      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3150      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3151      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3152      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3153      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3154      * its second operand, the expression on its right, and returns the value of that 
3155      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3156      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3157      * returning the unconverted value of the left-side expression.</p>
3158      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3159      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3160      * anonymously, returning the actual expression in the method overriding 
3161      * {@link Var#var()}.</p>
3162      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3163      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3164      * decrements, and function calls) for the second operand unless you are quite sure 
3165      * you know exactly what you are doing.</p>
3166      * <p>Despite the fairly confusing way that this operation actually works, it is 
3167      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3168      * Although it does not actually return a boolean value, the value it returns can always 
3169      * be converted to a boolean value.</p>
3170      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3171      * re-compilations. However, in most cases you can use the logical AND operator of the 
3172      * Java language like this:
3173      * <pre>Js.be(var) && Js.be(other)</pre>
3174      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3175      * JavaScript expression since the Java compilers generally used are free to compile 
3176      * the expression into any byte codes they think efficient, making it too hard for the 
3177      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3178      * @param var A value or object.
3179      * @param other A value or object.
3180      * @return The logical AND of the two operands.
3181      * @since 1.0
3182      * @javascript Re-compilers must replace the static invocation of this method with the 
3183      * JavaScript expression:
3184      * <pre>var && other</pre>
3185      */
3186     public static final <T> T and(T var, Var<? extends T> other) {
3187         return not(var) ? var : other == null ? (T)null : other.var();
3188     }
3189     /**
3190      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3191      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3192      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3193      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3194      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3195      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3196      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3197      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3198      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3199      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3200      * its second operand, the expression on its right, and returns the value of that 
3201      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3202      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3203      * returning the unconverted value of the left-side expression.</p>
3204      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3205      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3206      * anonymously, returning the actual expression in the method overriding 
3207      * {@link Var#var()}.</p>
3208      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3209      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3210      * decrements, and function calls) for the second operand unless you are quite sure 
3211      * you know exactly what you are doing.</p>
3212      * <p>Despite the fairly confusing way that this operation actually works, it is 
3213      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3214      * Although it does not actually return a boolean value, the value it returns can always 
3215      * be converted to a boolean value.</p>
3216      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3217      * re-compilations. However, in most cases you can use the logical AND operator of the 
3218      * Java language like this:
3219      * <pre>Js.be(var) && Js.be(other)</pre>
3220      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3221      * JavaScript expression since the Java compilers generally used are free to compile 
3222      * the expression into any byte codes they think efficient, making it too hard for the 
3223      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3224      * @param var A value or object.
3225      * @param other A value or object.
3226      * @return The logical AND of the two operands.
3227      * @since 1.0
3228      * @javascript Re-compilers must replace the static invocation of this method with the 
3229      * JavaScript expression:
3230      * <pre>var && other</pre>
3231      */
3232     public static final JsBoolean and(Boolean var, JsBoolean other) { return not(var) ? new JsBoolean(var) : other;}
3233     /**
3234      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3235      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3236      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3237      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3238      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3239      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3240      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3241      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3242      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3243      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3244      * its second operand, the expression on its right, and returns the value of that 
3245      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3246      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3247      * returning the unconverted value of the left-side expression.</p>
3248      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3249      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3250      * anonymously, returning the actual expression in the method overriding 
3251      * {@link Var#var()}.</p>
3252      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3253      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3254      * decrements, and function calls) for the second operand unless you are quite sure 
3255      * you know exactly what you are doing.</p>
3256      * <p>Despite the fairly confusing way that this operation actually works, it is 
3257      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3258      * Although it does not actually return a boolean value, the value it returns can always 
3259      * be converted to a boolean value.</p>
3260      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3261      * re-compilations. However, in most cases you can use the logical AND operator of the 
3262      * Java language like this:
3263      * <pre>Js.be(var) && Js.be(other)</pre>
3264      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3265      * JavaScript expression since the Java compilers generally used are free to compile 
3266      * the expression into any byte codes they think efficient, making it too hard for the 
3267      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3268      * @param var A value or object.
3269      * @param other A value or object.
3270      * @return The logical AND of the two operands.
3271      * @since 1.0
3272      * @javascript Re-compilers must replace the static invocation of this method with the 
3273      * JavaScript expression:
3274      * <pre>var && other</pre>
3275      */
3276     public static final JsBoolean and(Var<Boolean> var, JsBoolean other) { return not(var) ? new JsBoolean(valueOf(var.var())) : other;}
3277     /**
3278      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3279      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3280      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3281      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3282      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3283      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3284      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3285      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3286      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3287      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3288      * its second operand, the expression on its right, and returns the value of that 
3289      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3290      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3291      * returning the unconverted value of the left-side expression.</p>
3292      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3293      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3294      * anonymously, returning the actual expression in the method overriding 
3295      * {@link Var#var()}.</p>
3296      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3297      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3298      * decrements, and function calls) for the second operand unless you are quite sure 
3299      * you know exactly what you are doing.</p>
3300      * <p>Despite the fairly confusing way that this operation actually works, it is 
3301      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3302      * Although it does not actually return a boolean value, the value it returns can always 
3303      * be converted to a boolean value.</p>
3304      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3305      * re-compilations. However, in most cases you can use the logical AND operator of the 
3306      * Java language like this:
3307      * <pre>Js.be(var) && Js.be(other)</pre>
3308      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3309      * JavaScript expression since the Java compilers generally used are free to compile 
3310      * the expression into any byte codes they think efficient, making it too hard for the 
3311      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3312      * @param var A value or object.
3313      * @param other A value or object.
3314      * @return The logical AND of the two operands.
3315      * @since 1.0
3316      * @javascript Re-compilers must replace the static invocation of this method with the 
3317      * JavaScript expression:
3318      * <pre>var && other</pre>
3319      */
3320     public static final Boolean and(JsBoolean var, Boolean other) { return not(var) ? var.valueOf() : other;}
3321     /**
3322      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3323      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3324      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3325      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3326      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3327      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3328      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3329      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3330      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3331      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3332      * its second operand, the expression on its right, and returns the value of that 
3333      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3334      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3335      * returning the unconverted value of the left-side expression.</p>
3336      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3337      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3338      * anonymously, returning the actual expression in the method overriding 
3339      * {@link Var#var()}.</p>
3340      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3341      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3342      * decrements, and function calls) for the second operand unless you are quite sure 
3343      * you know exactly what you are doing.</p>
3344      * <p>Despite the fairly confusing way that this operation actually works, it is 
3345      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3346      * Although it does not actually return a boolean value, the value it returns can always 
3347      * be converted to a boolean value.</p>
3348      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3349      * re-compilations. However, in most cases you can use the logical AND operator of the 
3350      * Java language like this:
3351      * <pre>Js.be(var) && Js.be(other)</pre>
3352      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3353      * JavaScript expression since the Java compilers generally used are free to compile 
3354      * the expression into any byte codes they think efficient, making it too hard for the 
3355      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3356      * @param var A value or object.
3357      * @param other A value or object.
3358      * @return The logical AND of the two operands.
3359      * @since 1.0
3360      * @javascript Re-compilers must replace the static invocation of this method with the 
3361      * JavaScript expression:
3362      * <pre>var && other</pre>
3363      */
3364     public static final Boolean and(JsBoolean var, Var<Boolean> other) { return not(var) ? var.valueOf() : valueOf(other.var());}
3365     /**
3366      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3367      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3368      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3369      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3370      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3371      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3372      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3373      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3374      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3375      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3376      * its second operand, the expression on its right, and returns the value of that 
3377      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3378      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3379      * returning the unconverted value of the left-side expression.</p>
3380      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3381      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3382      * anonymously, returning the actual expression in the method overriding 
3383      * {@link Var#var()}.</p>
3384      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3385      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3386      * decrements, and function calls) for the second operand unless you are quite sure 
3387      * you know exactly what you are doing.</p>
3388      * <p>Despite the fairly confusing way that this operation actually works, it is 
3389      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3390      * Although it does not actually return a boolean value, the value it returns can always 
3391      * be converted to a boolean value.</p>
3392      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3393      * re-compilations. However, in most cases you can use the logical AND operator of the 
3394      * Java language like this:
3395      * <pre>Js.be(var) && Js.be(other)</pre>
3396      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3397      * JavaScript expression since the Java compilers generally used are free to compile 
3398      * the expression into any byte codes they think efficient, making it too hard for the 
3399      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3400      * @param var A value or object.
3401      * @param other A value or object.
3402      * @return The logical AND of the two operands.
3403      * @since 1.0
3404      * @javascript Re-compilers must replace the static invocation of this method with the 
3405      * JavaScript expression:
3406      * <pre>var && other</pre>
3407      */
3408     public static final JsNumber and(Character var, JsNumber other) { return not(var) ? new JsNumber(valueOf(var)) : other;}
3409     /**
3410      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3411      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3412      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3413      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3414      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3415      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3416      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3417      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3418      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3419      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3420      * its second operand, the expression on its right, and returns the value of that 
3421      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3422      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3423      * returning the unconverted value of the left-side expression.</p>
3424      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3425      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3426      * anonymously, returning the actual expression in the method overriding 
3427      * {@link Var#var()}.</p>
3428      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3429      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3430      * decrements, and function calls) for the second operand unless you are quite sure 
3431      * you know exactly what you are doing.</p>
3432      * <p>Despite the fairly confusing way that this operation actually works, it is 
3433      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3434      * Although it does not actually return a boolean value, the value it returns can always 
3435      * be converted to a boolean value.</p>
3436      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3437      * re-compilations. However, in most cases you can use the logical AND operator of the 
3438      * Java language like this:
3439      * <pre>Js.be(var) && Js.be(other)</pre>
3440      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3441      * JavaScript expression since the Java compilers generally used are free to compile 
3442      * the expression into any byte codes they think efficient, making it too hard for the 
3443      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3444      * @param var A value or object.
3445      * @param other A value or object.
3446      * @return The logical AND of the two operands.
3447      * @since 1.0
3448      * @javascript Re-compilers must replace the static invocation of this method with the 
3449      * JavaScript expression:
3450      * <pre>var && other</pre>
3451      */
3452     public static final JsNumber and(Number var, JsNumber other) { return not(var) ? new JsNumber(var) : other;}
3453     /**
3454      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3455      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3456      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3457      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3458      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3459      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3460      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3461      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3462      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3463      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3464      * its second operand, the expression on its right, and returns the value of that 
3465      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3466      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3467      * returning the unconverted value of the left-side expression.</p>
3468      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3469      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3470      * anonymously, returning the actual expression in the method overriding 
3471      * {@link Var#var()}.</p>
3472      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3473      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3474      * decrements, and function calls) for the second operand unless you are quite sure 
3475      * you know exactly what you are doing.</p>
3476      * <p>Despite the fairly confusing way that this operation actually works, it is 
3477      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3478      * Although it does not actually return a boolean value, the value it returns can always 
3479      * be converted to a boolean value.</p>
3480      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3481      * re-compilations. However, in most cases you can use the logical AND operator of the 
3482      * Java language like this:
3483      * <pre>Js.be(var) && Js.be(other)</pre>
3484      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3485      * JavaScript expression since the Java compilers generally used are free to compile 
3486      * the expression into any byte codes they think efficient, making it too hard for the 
3487      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3488      * @param var A value or object.
3489      * @param other A value or object.
3490      * @return The logical AND of the two operands.
3491      * @since 1.0
3492      * @javascript Re-compilers must replace the static invocation of this method with the 
3493      * JavaScript expression:
3494      * <pre>var && other</pre>
3495      */
3496     public static final JsNumber and(Var<? extends Number> var, JsNumber other) { return not(var) ? new JsNumber(valueOf(var)) : other;}
3497     /**
3498      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3499      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3500      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3501      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3502      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3503      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3504      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3505      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3506      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3507      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3508      * its second operand, the expression on its right, and returns the value of that 
3509      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3510      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3511      * returning the unconverted value of the left-side expression.</p>
3512      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3513      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3514      * anonymously, returning the actual expression in the method overriding 
3515      * {@link Var#var()}.</p>
3516      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3517      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3518      * decrements, and function calls) for the second operand unless you are quite sure 
3519      * you know exactly what you are doing.</p>
3520      * <p>Despite the fairly confusing way that this operation actually works, it is 
3521      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3522      * Although it does not actually return a boolean value, the value it returns can always 
3523      * be converted to a boolean value.</p>
3524      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3525      * re-compilations. However, in most cases you can use the logical AND operator of the 
3526      * Java language like this:
3527      * <pre>Js.be(var) && Js.be(other)</pre>
3528      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3529      * JavaScript expression since the Java compilers generally used are free to compile 
3530      * the expression into any byte codes they think efficient, making it too hard for the 
3531      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3532      * @param var A value or object.
3533      * @param other A value or object.
3534      * @return The logical AND of the two operands.
3535      * @since 1.0
3536      * @javascript Re-compilers must replace the static invocation of this method with the 
3537      * JavaScript expression:
3538      * <pre>var && other</pre>
3539      */
3540     public static final JsNumber and(Value<Character> var, JsNumber other) { return not(var) ? new JsNumber(valueOf(var.var())) : other;}
3541     /**
3542      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3543      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3544      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3545      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3546      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3547      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3548      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3549      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3550      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3551      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3552      * its second operand, the expression on its right, and returns the value of that 
3553      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3554      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3555      * returning the unconverted value of the left-side expression.</p>
3556      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3557      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3558      * anonymously, returning the actual expression in the method overriding 
3559      * {@link Var#var()}.</p>
3560      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3561      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3562      * decrements, and function calls) for the second operand unless you are quite sure 
3563      * you know exactly what you are doing.</p>
3564      * <p>Despite the fairly confusing way that this operation actually works, it is 
3565      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3566      * Although it does not actually return a boolean value, the value it returns can always 
3567      * be converted to a boolean value.</p>
3568      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3569      * re-compilations. However, in most cases you can use the logical AND operator of the 
3570      * Java language like this:
3571      * <pre>Js.be(var) && Js.be(other)</pre>
3572      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3573      * JavaScript expression since the Java compilers generally used are free to compile 
3574      * the expression into any byte codes they think efficient, making it too hard for the 
3575      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3576      * @param var A value or object.
3577      * @param other A value or object.
3578      * @return The logical AND of the two operands.
3579      * @since 1.0
3580      * @javascript Re-compilers must replace the static invocation of this method with the 
3581      * JavaScript expression:
3582      * <pre>var && other</pre>
3583      */
3584     public static final Number and(JsNumber var, Character other) { return not(var) ? var.valueOf() : valueOf(other);}
3585     /**
3586      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3587      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3588      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3589      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3590      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3591      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3592      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3593      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3594      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3595      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3596      * its second operand, the expression on its right, and returns the value of that 
3597      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3598      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3599      * returning the unconverted value of the left-side expression.</p>
3600      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3601      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3602      * anonymously, returning the actual expression in the method overriding 
3603      * {@link Var#var()}.</p>
3604      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3605      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3606      * decrements, and function calls) for the second operand unless you are quite sure 
3607      * you know exactly what you are doing.</p>
3608      * <p>Despite the fairly confusing way that this operation actually works, it is 
3609      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3610      * Although it does not actually return a boolean value, the value it returns can always 
3611      * be converted to a boolean value.</p>
3612      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3613      * re-compilations. However, in most cases you can use the logical AND operator of the 
3614      * Java language like this:
3615      * <pre>Js.be(var) && Js.be(other)</pre>
3616      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3617      * JavaScript expression since the Java compilers generally used are free to compile 
3618      * the expression into any byte codes they think efficient, making it too hard for the 
3619      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3620      * @param var A value or object.
3621      * @param other A value or object.
3622      * @return The logical AND of the two operands.
3623      * @since 1.0
3624      * @javascript Re-compilers must replace the static invocation of this method with the 
3625      * JavaScript expression:
3626      * <pre>var && other</pre>
3627      */
3628     public static final Number and(JsNumber var, Number other) { return not(var) ? var.valueOf() : other;}
3629     /**
3630      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3631      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3632      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3633      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3634      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3635      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3636      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3637      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3638      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3639      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3640      * its second operand, the expression on its right, and returns the value of that 
3641      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3642      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3643      * returning the unconverted value of the left-side expression.</p>
3644      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3645      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3646      * anonymously, returning the actual expression in the method overriding 
3647      * {@link Var#var()}.</p>
3648      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3649      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3650      * decrements, and function calls) for the second operand unless you are quite sure 
3651      * you know exactly what you are doing.</p>
3652      * <p>Despite the fairly confusing way that this operation actually works, it is 
3653      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3654      * Although it does not actually return a boolean value, the value it returns can always 
3655      * be converted to a boolean value.</p>
3656      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3657      * re-compilations. However, in most cases you can use the logical AND operator of the 
3658      * Java language like this:
3659      * <pre>Js.be(var) && Js.be(other)</pre>
3660      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3661      * JavaScript expression since the Java compilers generally used are free to compile 
3662      * the expression into any byte codes they think efficient, making it too hard for the 
3663      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3664      * @param var A value or object.
3665      * @param other A value or object.
3666      * @return The logical AND of the two operands.
3667      * @since 1.0
3668      * @javascript Re-compilers must replace the static invocation of this method with the 
3669      * JavaScript expression:
3670      * <pre>var && other</pre>
3671      */
3672     public static final Number and(JsNumber var, Var<? extends Number> other) { return not(var) ? var.valueOf() : valueOf(other);}
3673     /**
3674      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3675      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3676      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3677      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3678      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3679      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3680      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3681      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3682      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3683      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3684      * its second operand, the expression on its right, and returns the value of that 
3685      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3686      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3687      * returning the unconverted value of the left-side expression.</p>
3688      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3689      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3690      * anonymously, returning the actual expression in the method overriding 
3691      * {@link Var#var()}.</p>
3692      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3693      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3694      * decrements, and function calls) for the second operand unless you are quite sure 
3695      * you know exactly what you are doing.</p>
3696      * <p>Despite the fairly confusing way that this operation actually works, it is 
3697      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3698      * Although it does not actually return a boolean value, the value it returns can always 
3699      * be converted to a boolean value.</p>
3700      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3701      * re-compilations. However, in most cases you can use the logical AND operator of the 
3702      * Java language like this:
3703      * <pre>Js.be(var) && Js.be(other)</pre>
3704      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3705      * JavaScript expression since the Java compilers generally used are free to compile 
3706      * the expression into any byte codes they think efficient, making it too hard for the 
3707      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3708      * @param var A value or object.
3709      * @param other A value or object.
3710      * @return The logical AND of the two operands.
3711      * @since 1.0
3712      * @javascript Re-compilers must replace the static invocation of this method with the 
3713      * JavaScript expression:
3714      * <pre>var && other</pre>
3715      */
3716     public static final Number and(JsNumber var, Value<Character> other) { return not(var) ? var.valueOf() : valueOf(other.var());}
3717     /**
3718      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3719      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3720      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3721      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3722      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3723      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3724      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3725      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3726      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3727      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3728      * its second operand, the expression on its right, and returns the value of that 
3729      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3730      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3731      * returning the unconverted value of the left-side expression.</p>
3732      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3733      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3734      * anonymously, returning the actual expression in the method overriding 
3735      * {@link Var#var()}.</p>
3736      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3737      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3738      * decrements, and function calls) for the second operand unless you are quite sure 
3739      * you know exactly what you are doing.</p>
3740      * <p>Despite the fairly confusing way that this operation actually works, it is 
3741      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3742      * Although it does not actually return a boolean value, the value it returns can always 
3743      * be converted to a boolean value.</p>
3744      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3745      * re-compilations. However, in most cases you can use the logical AND operator of the 
3746      * Java language like this:
3747      * <pre>Js.be(var) && Js.be(other)</pre>
3748      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3749      * JavaScript expression since the Java compilers generally used are free to compile 
3750      * the expression into any byte codes they think efficient, making it too hard for the 
3751      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3752      * @param var A value or object.
3753      * @param other A value or object.
3754      * @return The logical AND of the two operands.
3755      * @since 1.0
3756      * @javascript Re-compilers must replace the static invocation of this method with the 
3757      * JavaScript expression:
3758      * <pre>var && other</pre>
3759      */
3760     public static final JsString and(String var, JsString other) { return not(var) ? new JsString(var) : other;}
3761     /**
3762      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3763      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3764      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3765      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3766      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3767      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3768      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3769      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3770      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3771      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3772      * its second operand, the expression on its right, and returns the value of that 
3773      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3774      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3775      * returning the unconverted value of the left-side expression.</p>
3776      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3777      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3778      * anonymously, returning the actual expression in the method overriding 
3779      * {@link Var#var()}.</p>
3780      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3781      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3782      * decrements, and function calls) for the second operand unless you are quite sure 
3783      * you know exactly what you are doing.</p>
3784      * <p>Despite the fairly confusing way that this operation actually works, it is 
3785      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3786      * Although it does not actually return a boolean value, the value it returns can always 
3787      * be converted to a boolean value.</p>
3788      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3789      * re-compilations. However, in most cases you can use the logical AND operator of the 
3790      * Java language like this:
3791      * <pre>Js.be(var) && Js.be(other)</pre>
3792      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3793      * JavaScript expression since the Java compilers generally used are free to compile 
3794      * the expression into any byte codes they think efficient, making it too hard for the 
3795      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3796      * @param var A value or object.
3797      * @param other A value or object.
3798      * @return The logical AND of the two operands.
3799      * @since 1.0
3800      * @javascript Re-compilers must replace the static invocation of this method with the 
3801      * JavaScript expression:
3802      * <pre>var && other</pre>
3803      */
3804     public static final JsString and(Var<String> var, JsString other) { return not(var) ? new JsString(var.var()) : other;}
3805     /**
3806      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3807      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3808      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3809      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3810      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3811      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3812      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3813      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3814      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3815      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3816      * its second operand, the expression on its right, and returns the value of that 
3817      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3818      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3819      * returning the unconverted value of the left-side expression.</p>
3820      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3821      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3822      * anonymously, returning the actual expression in the method overriding 
3823      * {@link Var#var()}.</p>
3824      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3825      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3826      * decrements, and function calls) for the second operand unless you are quite sure 
3827      * you know exactly what you are doing.</p>
3828      * <p>Despite the fairly confusing way that this operation actually works, it is 
3829      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3830      * Although it does not actually return a boolean value, the value it returns can always 
3831      * be converted to a boolean value.</p>
3832      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3833      * re-compilations. However, in most cases you can use the logical AND operator of the 
3834      * Java language like this:
3835      * <pre>Js.be(var) && Js.be(other)</pre>
3836      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3837      * JavaScript expression since the Java compilers generally used are free to compile 
3838      * the expression into any byte codes they think efficient, making it too hard for the 
3839      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3840      * @param var A value or object.
3841      * @param other A value or object.
3842      * @return The logical AND of the two operands.
3843      * @since 1.0
3844      * @javascript Re-compilers must replace the static invocation of this method with the 
3845      * JavaScript expression:
3846      * <pre>var && other</pre>
3847      */
3848     public static final String and(JsString var, String other) { return not(var) ? var.valueOf() : other;}
3849     /**
3850      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3851      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3852      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3853      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3854      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3855      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3856      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3857      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3858      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3859      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3860      * its second operand, the expression on its right, and returns the value of that 
3861      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3862      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3863      * returning the unconverted value of the left-side expression.</p>
3864      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3865      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3866      * anonymously, returning the actual expression in the method overriding 
3867      * {@link Var#var()}.</p>
3868      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3869      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3870      * decrements, and function calls) for the second operand unless you are quite sure 
3871      * you know exactly what you are doing.</p>
3872      * <p>Despite the fairly confusing way that this operation actually works, it is 
3873      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3874      * Although it does not actually return a boolean value, the value it returns can always 
3875      * be converted to a boolean value.</p>
3876      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3877      * re-compilations. However, in most cases you can use the logical AND operator of the 
3878      * Java language like this:
3879      * <pre>Js.be(var) && Js.be(other)</pre>
3880      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3881      * JavaScript expression since the Java compilers generally used are free to compile 
3882      * the expression into any byte codes they think efficient, making it too hard for the 
3883      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3884      * @param var A value or object.
3885      * @param other A value or object.
3886      * @return The logical AND of the two operands.
3887      * @since 1.0
3888      * @javascript Re-compilers must replace the static invocation of this method with the 
3889      * JavaScript expression:
3890      * <pre>var && other</pre>
3891      */
3892     public static final String and(JsString var, Var<String> other) { return not(var) ? var.valueOf() : other.var();}
3893 
3894     /**
3895      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3896      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3897      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3898      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3899      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3900      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3901      * its first operand, the expression on its left. If the value of this expression can 
3902      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3903      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3904      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3905      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3906      * and doesn't return the unconverted value of the left-side expression.</p>
3907      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3908      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3909      * anonymously, returning the actual expression in the method overriding 
3910      * {@link Var#var()}.</p>
3911      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
3912      * operands that include side effects, unless you purposely want to use the fact that 
3913      * the right-side expression may not be evaluated in JavaScript.</p>
3914      * <p>Even when this operation is used with operands that are not boolean values, it 
3915      * can still be considered a Boolean OR operator because its return value, whatever the 
3916      * type, can be converted to a boolean value.</p>
3917      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3918      * re-compilations. However, in most cases you can use the logical OR operator of the 
3919      * Java language like this:
3920      * <pre>Js.be(var) || Js.be(other)</pre>
3921      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3922      * JavaScript expression since the Java compilers generally used are free to compile 
3923      * the expression into any byte codes they think efficient, making it too hard for the 
3924      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3925      * @param var A value or object.
3926      * @param other A value or object.
3927      * @return The logical OR of the two operands.
3928      * @since 1.0
3929      * @javascript Re-compilers must replace the static invocation of this method with the 
3930      * JavaScript expression:
3931      * <pre>var || other</pre>
3932      */
3933     public static final <T> T or(T var, T other) { return be(var) ? var : other;}
3934     /**
3935      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3936      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3937      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3938      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3939      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3940      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3941      * its first operand, the expression on its left. If the value of this expression can 
3942      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3943      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3944      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3945      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3946      * and doesn't return the unconverted value of the left-side expression.</p>
3947      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3948      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3949      * anonymously, returning the actual expression in the method overriding 
3950      * {@link Var#var()}.</p>
3951      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
3952      * operands that include side effects, unless you purposely want to use the fact that 
3953      * the right-side expression may not be evaluated in JavaScript.</p>
3954      * <p>Even when this operation is used with operands that are not boolean values, it 
3955      * can still be considered a Boolean OR operator because its return value, whatever the 
3956      * type, can be converted to a boolean value.</p>
3957      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3958      * re-compilations. However, in most cases you can use the logical OR operator of the 
3959      * Java language like this:
3960      * <pre>Js.be(var) || Js.be(other)</pre>
3961      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3962      * JavaScript expression since the Java compilers generally used are free to compile 
3963      * the expression into any byte codes they think efficient, making it too hard for the 
3964      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3965      * @param var A value or object.
3966      * @param other A value or object.
3967      * @return The logical OR of the two operands.
3968      * @since 1.0
3969      * @javascript Re-compilers must replace the static invocation of this method with the 
3970      * JavaScript expression:
3971      * <pre>var || other</pre>
3972      */
3973     public static final <T> T or(Var<? extends T> var, T other) {
3974         T v = var == null ? (T)null : var.var();
3975         return be(v) ? v : other;
3976     }
3977     /**
3978      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3979      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3980      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3981      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3982      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3983      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3984      * its first operand, the expression on its left. If the value of this expression can 
3985      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3986      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3987      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3988      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3989      * and doesn't return the unconverted value of the left-side expression.</p>
3990      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3991      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3992      * anonymously, returning the actual expression in the method overriding 
3993      * {@link Var#var()}.</p>
3994      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
3995      * operands that include side effects, unless you purposely want to use the fact that 
3996      * the right-side expression may not be evaluated in JavaScript.</p>
3997      * <p>Even when this operation is used with operands that are not boolean values, it 
3998      * can still be considered a Boolean OR operator because its return value, whatever the 
3999      * type, can be converted to a boolean value.</p>
4000      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4001      * re-compilations. However, in most cases you can use the logical OR operator of the 
4002      * Java language like this:
4003      * <pre>Js.be(var) || Js.be(other)</pre>
4004      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4005      * JavaScript expression since the Java compilers generally used are free to compile 
4006      * the expression into any byte codes they think efficient, making it too hard for the 
4007      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4008      * @param var A value or object.
4009      * @param other A value or object.
4010      * @return The logical OR of the two operands.
4011      * @since 1.0
4012      * @javascript Re-compilers must replace the static invocation of this method with the 
4013      * JavaScript expression:
4014      * <pre>var || other</pre>
4015      */
4016     public static final <T> T or(T var, Var<? extends T> other) {
4017         return be(var) ? var : other == null ? (T)null : other.var();
4018     }
4019     /**
4020      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4021      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4022      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4023      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4024      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4025      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4026      * its first operand, the expression on its left. If the value of this expression can 
4027      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4028      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4029      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4030      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4031      * and doesn't return the unconverted value of the left-side expression.</p>
4032      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4033      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4034      * anonymously, returning the actual expression in the method overriding 
4035      * {@link Var#var()}.</p>
4036      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4037      * operands that include side effects, unless you purposely want to use the fact that 
4038      * the right-side expression may not be evaluated in JavaScript.</p>
4039      * <p>Even when this operation is used with operands that are not boolean values, it 
4040      * can still be considered a Boolean OR operator because its return value, whatever the 
4041      * type, can be converted to a boolean value.</p>
4042      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4043      * re-compilations. However, in most cases you can use the logical OR operator of the 
4044      * Java language like this:
4045      * <pre>Js.be(var) || Js.be(other)</pre>
4046      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4047      * JavaScript expression since the Java compilers generally used are free to compile 
4048      * the expression into any byte codes they think efficient, making it too hard for the 
4049      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4050      * @param var A value or object.
4051      * @param other A value or object.
4052      * @return The logical OR of the two operands.
4053      * @since 1.0
4054      * @javascript Re-compilers must replace the static invocation of this method with the 
4055      * JavaScript expression:
4056      * <pre>var || other</pre>
4057      */
4058     public static final JsBoolean or(JsBoolean var, Boolean other) { return be(var) ? var : new JsBoolean(other);}
4059     /**
4060      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4061      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4062      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4063      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4064      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4065      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4066      * its first operand, the expression on its left. If the value of this expression can 
4067      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4068      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4069      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4070      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4071      * and doesn't return the unconverted value of the left-side expression.</p>
4072      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4073      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4074      * anonymously, returning the actual expression in the method overriding 
4075      * {@link Var#var()}.</p>
4076      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4077      * operands that include side effects, unless you purposely want to use the fact that 
4078      * the right-side expression may not be evaluated in JavaScript.</p>
4079      * <p>Even when this operation is used with operands that are not boolean values, it 
4080      * can still be considered a Boolean OR operator because its return value, whatever the 
4081      * type, can be converted to a boolean value.</p>
4082      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4083      * re-compilations. However, in most cases you can use the logical OR operator of the 
4084      * Java language like this:
4085      * <pre>Js.be(var) || Js.be(other)</pre>
4086      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4087      * JavaScript expression since the Java compilers generally used are free to compile 
4088      * the expression into any byte codes they think efficient, making it too hard for the 
4089      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4090      * @param var A value or object.
4091      * @param other A value or object.
4092      * @return The logical OR of the two operands.
4093      * @since 1.0
4094      * @javascript Re-compilers must replace the static invocation of this method with the 
4095      * JavaScript expression:
4096      * <pre>var || other</pre>
4097      */
4098     public static final JsBoolean or(JsBoolean var, Var<Boolean> other) { return be(var) ? var : new JsBoolean(other.var());}
4099     /**
4100      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4101      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4102      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4103      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4104      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4105      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4106      * its first operand, the expression on its left. If the value of this expression can 
4107      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4108      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4109      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4110      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4111      * and doesn't return the unconverted value of the left-side expression.</p>
4112      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4113      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4114      * anonymously, returning the actual expression in the method overriding 
4115      * {@link Var#var()}.</p>
4116      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4117      * operands that include side effects, unless you purposely want to use the fact that 
4118      * the right-side expression may not be evaluated in JavaScript.</p>
4119      * <p>Even when this operation is used with operands that are not boolean values, it 
4120      * can still be considered a Boolean OR operator because its return value, whatever the 
4121      * type, can be converted to a boolean value.</p>
4122      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4123      * re-compilations. However, in most cases you can use the logical OR operator of the 
4124      * Java language like this:
4125      * <pre>Js.be(var) || Js.be(other)</pre>
4126      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4127      * JavaScript expression since the Java compilers generally used are free to compile 
4128      * the expression into any byte codes they think efficient, making it too hard for the 
4129      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4130      * @param var A value or object.
4131      * @param other A value or object.
4132      * @return The logical OR of the two operands.
4133      * @since 1.0
4134      * @javascript Re-compilers must replace the static invocation of this method with the 
4135      * JavaScript expression:
4136      * <pre>var || other</pre>
4137      */
4138     public static final Boolean or(Boolean var, JsBoolean other) { return be(var) ? var : valueOf(other);}
4139     /**
4140      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4141      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4142      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4143      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4144      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4145      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4146      * its first operand, the expression on its left. If the value of this expression can 
4147      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4148      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4149      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4150      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4151      * and doesn't return the unconverted value of the left-side expression.</p>
4152      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4153      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4154      * anonymously, returning the actual expression in the method overriding 
4155      * {@link Var#var()}.</p>
4156      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4157      * operands that include side effects, unless you purposely want to use the fact that 
4158      * the right-side expression may not be evaluated in JavaScript.</p>
4159      * <p>Even when this operation is used with operands that are not boolean values, it 
4160      * can still be considered a Boolean OR operator because its return value, whatever the 
4161      * type, can be converted to a boolean value.</p>
4162      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4163      * re-compilations. However, in most cases you can use the logical OR operator of the 
4164      * Java language like this:
4165      * <pre>Js.be(var) || Js.be(other)</pre>
4166      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4167      * JavaScript expression since the Java compilers generally used are free to compile 
4168      * the expression into any byte codes they think efficient, making it too hard for the 
4169      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4170      * @param var A value or object.
4171      * @param other A value or object.
4172      * @return The logical OR of the two operands.
4173      * @since 1.0
4174      * @javascript Re-compilers must replace the static invocation of this method with the 
4175      * JavaScript expression:
4176      * <pre>var || other</pre>
4177      */
4178     public static final Boolean or(Var<Boolean> var, JsBoolean other) { return be(var) ? var.var() : valueOf(other);}
4179     /**
4180      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4181      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4182      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4183      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4184      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4185      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4186      * its first operand, the expression on its left. If the value of this expression can 
4187      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4188      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4189      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4190      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4191      * and doesn't return the unconverted value of the left-side expression.</p>
4192      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4193      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4194      * anonymously, returning the actual expression in the method overriding 
4195      * {@link Var#var()}.</p>
4196      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4197      * operands that include side effects, unless you purposely want to use the fact that 
4198      * the right-side expression may not be evaluated in JavaScript.</p>
4199      * <p>Even when this operation is used with operands that are not boolean values, it 
4200      * can still be considered a Boolean OR operator because its return value, whatever the 
4201      * type, can be converted to a boolean value.</p>
4202      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4203      * re-compilations. However, in most cases you can use the logical OR operator of the 
4204      * Java language like this:
4205      * <pre>Js.be(var) || Js.be(other)</pre>
4206      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4207      * JavaScript expression since the Java compilers generally used are free to compile 
4208      * the expression into any byte codes they think efficient, making it too hard for the 
4209      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4210      * @param var A value or object.
4211      * @param other A value or object.
4212      * @return The logical OR of the two operands.
4213      * @since 1.0
4214      * @javascript Re-compilers must replace the static invocation of this method with the 
4215      * JavaScript expression:
4216      * <pre>var || other</pre>
4217      */
4218     public static final JsNumber or(JsNumber var, Character other) { return be(var) ? var : new JsNumber(valueOf(other));}
4219     /**
4220      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4221      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4222      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4223      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4224      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4225      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4226      * its first operand, the expression on its left. If the value of this expression can 
4227      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4228      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4229      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4230      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4231      * and doesn't return the unconverted value of the left-side expression.</p>
4232      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4233      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4234      * anonymously, returning the actual expression in the method overriding 
4235      * {@link Var#var()}.</p>
4236      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4237      * operands that include side effects, unless you purposely want to use the fact that 
4238      * the right-side expression may not be evaluated in JavaScript.</p>
4239      * <p>Even when this operation is used with operands that are not boolean values, it 
4240      * can still be considered a Boolean OR operator because its return value, whatever the 
4241      * type, can be converted to a boolean value.</p>
4242      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4243      * re-compilations. However, in most cases you can use the logical OR operator of the 
4244      * Java language like this:
4245      * <pre>Js.be(var) || Js.be(other)</pre>
4246      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4247      * JavaScript expression since the Java compilers generally used are free to compile 
4248      * the expression into any byte codes they think efficient, making it too hard for the 
4249      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4250      * @param var A value or object.
4251      * @param other A value or object.
4252      * @return The logical OR of the two operands.
4253      * @since 1.0
4254      * @javascript Re-compilers must replace the static invocation of this method with the 
4255      * JavaScript expression:
4256      * <pre>var || other</pre>
4257      */
4258     public static final JsNumber or(JsNumber var, Number other) { return be(var) ? var : new JsNumber(other);}
4259     /**
4260      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4261      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4262      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4263      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4264      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4265      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4266      * its first operand, the expression on its left. If the value of this expression can 
4267      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4268      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4269      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4270      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4271      * and doesn't return the unconverted value of the left-side expression.</p>
4272      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4273      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4274      * anonymously, returning the actual expression in the method overriding 
4275      * {@link Var#var()}.</p>
4276      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4277      * operands that include side effects, unless you purposely want to use the fact that 
4278      * the right-side expression may not be evaluated in JavaScript.</p>
4279      * <p>Even when this operation is used with operands that are not boolean values, it 
4280      * can still be considered a Boolean OR operator because its return value, whatever the 
4281      * type, can be converted to a boolean value.</p>
4282      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4283      * re-compilations. However, in most cases you can use the logical OR operator of the 
4284      * Java language like this:
4285      * <pre>Js.be(var) || Js.be(other)</pre>
4286      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4287      * JavaScript expression since the Java compilers generally used are free to compile 
4288      * the expression into any byte codes they think efficient, making it too hard for the 
4289      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4290      * @param var A value or object.
4291      * @param other A value or object.
4292      * @return The logical OR of the two operands.
4293      * @since 1.0
4294      * @javascript Re-compilers must replace the static invocation of this method with the 
4295      * JavaScript expression:
4296      * <pre>var || other</pre>
4297      */
4298     public static final JsNumber or(JsNumber var, Var<? extends Number> other) { return be(var) ? var : new JsNumber(valueOf(other));}
4299     /**
4300      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4301      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4302      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4303      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4304      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4305      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4306      * its first operand, the expression on its left. If the value of this expression can 
4307      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4308      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4309      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4310      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4311      * and doesn't return the unconverted value of the left-side expression.</p>
4312      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4313      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4314      * anonymously, returning the actual expression in the method overriding 
4315      * {@link Var#var()}.</p>
4316      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4317      * operands that include side effects, unless you purposely want to use the fact that 
4318      * the right-side expression may not be evaluated in JavaScript.</p>
4319      * <p>Even when this operation is used with operands that are not boolean values, it 
4320      * can still be considered a Boolean OR operator because its return value, whatever the 
4321      * type, can be converted to a boolean value.</p>
4322      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4323      * re-compilations. However, in most cases you can use the logical OR operator of the 
4324      * Java language like this:
4325      * <pre>Js.be(var) || Js.be(other)</pre>
4326      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4327      * JavaScript expression since the Java compilers generally used are free to compile 
4328      * the expression into any byte codes they think efficient, making it too hard for the 
4329      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4330      * @param var A value or object.
4331      * @param other A value or object.
4332      * @return The logical OR of the two operands.
4333      * @since 1.0
4334      * @javascript Re-compilers must replace the static invocation of this method with the 
4335      * JavaScript expression:
4336      * <pre>var || other</pre>
4337      */
4338     public static final JsNumber or(JsNumber var, Value<Character> other) { return be(var) ? var : new JsNumber(valueOf(other.var()));}
4339     /**
4340      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4341      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4342      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4343      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4344      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4345      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4346      * its first operand, the expression on its left. If the value of this expression can 
4347      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4348      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4349      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4350      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4351      * and doesn't return the unconverted value of the left-side expression.</p>
4352      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4353      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4354      * anonymously, returning the actual expression in the method overriding 
4355      * {@link Var#var()}.</p>
4356      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4357      * operands that include side effects, unless you purposely want to use the fact that 
4358      * the right-side expression may not be evaluated in JavaScript.</p>
4359      * <p>Even when this operation is used with operands that are not boolean values, it 
4360      * can still be considered a Boolean OR operator because its return value, whatever the 
4361      * type, can be converted to a boolean value.</p>
4362      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4363      * re-compilations. However, in most cases you can use the logical OR operator of the 
4364      * Java language like this:
4365      * <pre>Js.be(var) || Js.be(other)</pre>
4366      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4367      * JavaScript expression since the Java compilers generally used are free to compile 
4368      * the expression into any byte codes they think efficient, making it too hard for the 
4369      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4370      * @param var A value or object.
4371      * @param other A value or object.
4372      * @return The logical OR of the two operands.
4373      * @since 1.0
4374      * @javascript Re-compilers must replace the static invocation of this method with the 
4375      * JavaScript expression:
4376      * <pre>var || other</pre>
4377      */
4378     public static final Number or(Number var, JsNumber other) { return be(var) ? var : valueOf(other);}
4379     /**
4380      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4381      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4382      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4383      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4384      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4385      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4386      * its first operand, the expression on its left. If the value of this expression can 
4387      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4388      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4389      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4390      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4391      * and doesn't return the unconverted value of the left-side expression.</p>
4392      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4393      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4394      * anonymously, returning the actual expression in the method overriding 
4395      * {@link Var#var()}.</p>
4396      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4397      * operands that include side effects, unless you purposely want to use the fact that 
4398      * the right-side expression may not be evaluated in JavaScript.</p>
4399      * <p>Even when this operation is used with operands that are not boolean values, it 
4400      * can still be considered a Boolean OR operator because its return value, whatever the 
4401      * type, can be converted to a boolean value.</p>
4402      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4403      * re-compilations. However, in most cases you can use the logical OR operator of the 
4404      * Java language like this:
4405      * <pre>Js.be(var) || Js.be(other)</pre>
4406      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4407      * JavaScript expression since the Java compilers generally used are free to compile 
4408      * the expression into any byte codes they think efficient, making it too hard for the 
4409      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4410      * @param var A value or object.
4411      * @param other A value or object.
4412      * @return The logical OR of the two operands.
4413      * @since 1.0
4414      * @javascript Re-compilers must replace the static invocation of this method with the 
4415      * JavaScript expression:
4416      * <pre>var || other</pre>
4417      */
4418     public static final Number or(Character var, JsNumber other) { return be(var) ? valueOf(var) : valueOf(other);}
4419     /**
4420      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4421      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4422      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4423      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4424      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4425      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4426      * its first operand, the expression on its left. If the value of this expression can 
4427      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4428      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4429      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4430      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4431      * and doesn't return the unconverted value of the left-side expression.</p>
4432      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4433      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4434      * anonymously, returning the actual expression in the method overriding 
4435      * {@link Var#var()}.</p>
4436      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4437      * operands that include side effects, unless you purposely want to use the fact that 
4438      * the right-side expression may not be evaluated in JavaScript.</p>
4439      * <p>Even when this operation is used with operands that are not boolean values, it 
4440      * can still be considered a Boolean OR operator because its return value, whatever the 
4441      * type, can be converted to a boolean value.</p>
4442      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4443      * re-compilations. However, in most cases you can use the logical OR operator of the 
4444      * Java language like this:
4445      * <pre>Js.be(var) || Js.be(other)</pre>
4446      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4447      * JavaScript expression since the Java compilers generally used are free to compile 
4448      * the expression into any byte codes they think efficient, making it too hard for the 
4449      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4450      * @param var A value or object.
4451      * @param other A value or object.
4452      * @return The logical OR of the two operands.
4453      * @since 1.0
4454      * @javascript Re-compilers must replace the static invocation of this method with the 
4455      * JavaScript expression:
4456      * <pre>var || other</pre>
4457      */
4458     public static final Number or(Var<? extends Number> var, JsNumber other) { return be(var) ? var.var() : valueOf(other);}
4459     /**
4460      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4461      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4462      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4463      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4464      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4465      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4466      * its first operand, the expression on its left. If the value of this expression can 
4467      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4468      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4469      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4470      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4471      * and doesn't return the unconverted value of the left-side expression.</p>
4472      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4473      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4474      * anonymously, returning the actual expression in the method overriding 
4475      * {@link Var#var()}.</p>
4476      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4477      * operands that include side effects, unless you purposely want to use the fact that 
4478      * the right-side expression may not be evaluated in JavaScript.</p>
4479      * <p>Even when this operation is used with operands that are not boolean values, it 
4480      * can still be considered a Boolean OR operator because its return value, whatever the 
4481      * type, can be converted to a boolean value.</p>
4482      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4483      * re-compilations. However, in most cases you can use the logical OR operator of the 
4484      * Java language like this:
4485      * <pre>Js.be(var) || Js.be(other)</pre>
4486      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4487      * JavaScript expression since the Java compilers generally used are free to compile 
4488      * the expression into any byte codes they think efficient, making it too hard for the 
4489      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4490      * @param var A value or object.
4491      * @param other A value or object.
4492      * @return The logical OR of the two operands.
4493      * @since 1.0
4494      * @javascript Re-compilers must replace the static invocation of this method with the 
4495      * JavaScript expression:
4496      * <pre>var || other</pre>
4497      */
4498     public static final Number or(Value<Character> var, JsNumber other) { return be(var) ? valueOf(var.var()) : valueOf(other);}
4499     /**
4500      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4501      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4502      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4503      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4504      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4505      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4506      * its first operand, the expression on its left. If the value of this expression can 
4507      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4508      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4509      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4510      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4511      * and doesn't return the unconverted value of the left-side expression.</p>
4512      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4513      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4514      * anonymously, returning the actual expression in the method overriding 
4515      * {@link Var#var()}.</p>
4516      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4517      * operands that include side effects, unless you purposely want to use the fact that 
4518      * the right-side expression may not be evaluated in JavaScript.</p>
4519      * <p>Even when this operation is used with operands that are not boolean values, it 
4520      * can still be considered a Boolean OR operator because its return value, whatever the 
4521      * type, can be converted to a boolean value.</p>
4522      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4523      * re-compilations. However, in most cases you can use the logical OR operator of the 
4524      * Java language like this:
4525      * <pre>Js.be(var) || Js.be(other)</pre>
4526      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4527      * JavaScript expression since the Java compilers generally used are free to compile 
4528      * the expression into any byte codes they think efficient, making it too hard for the 
4529      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4530      * @param var A value or object.
4531      * @param other A value or object.
4532      * @return The logical OR of the two operands.
4533      * @since 1.0
4534      * @javascript Re-compilers must replace the static invocation of this method with the 
4535      * JavaScript expression:
4536      * <pre>var || other</pre>
4537      */
4538     public static final JsString or(JsString var, String other) { return be(var) ? var : new JsString(other);}
4539     /**
4540      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4541      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4542      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4543      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4544      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4545      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4546      * its first operand, the expression on its left. If the value of this expression can 
4547      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4548      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4549      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4550      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4551      * and doesn't return the unconverted value of the left-side expression.</p>
4552      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4553      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4554      * anonymously, returning the actual expression in the method overriding 
4555      * {@link Var#var()}.</p>
4556      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4557      * operands that include side effects, unless you purposely want to use the fact that 
4558      * the right-side expression may not be evaluated in JavaScript.</p>
4559      * <p>Even when this operation is used with operands that are not boolean values, it 
4560      * can still be considered a Boolean OR operator because its return value, whatever the 
4561      * type, can be converted to a boolean value.</p>
4562      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4563      * re-compilations. However, in most cases you can use the logical OR operator of the 
4564      * Java language like this:
4565      * <pre>Js.be(var) || Js.be(other)</pre>
4566      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4567      * JavaScript expression since the Java compilers generally used are free to compile 
4568      * the expression into any byte codes they think efficient, making it too hard for the 
4569      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4570      * @param var A value or object.
4571      * @param other A value or object.
4572      * @return The logical OR of the two operands.
4573      * @since 1.0
4574      * @javascript Re-compilers must replace the static invocation of this method with the 
4575      * JavaScript expression:
4576      * <pre>var || other</pre>
4577      */
4578     public static final JsString or(JsString var, Var<String> other) { return be(var) ? var : new JsString(other.var());}
4579     /**
4580      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4581      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4582      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4583      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4584      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4585      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4586      * its first operand, the expression on its left. If the value of this expression can 
4587      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4588      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4589      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4590      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4591      * and doesn't return the unconverted value of the left-side expression.</p>
4592      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4593      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4594      * anonymously, returning the actual expression in the method overriding 
4595      * {@link Var#var()}.</p>
4596      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4597      * operands that include side effects, unless you purposely want to use the fact that 
4598      * the right-side expression may not be evaluated in JavaScript.</p>
4599      * <p>Even when this operation is used with operands that are not boolean values, it 
4600      * can still be considered a Boolean OR operator because its return value, whatever the 
4601      * type, can be converted to a boolean value.</p>
4602      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4603      * re-compilations. However, in most cases you can use the logical OR operator of the 
4604      * Java language like this:
4605      * <pre>Js.be(var) || Js.be(other)</pre>
4606      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4607      * JavaScript expression since the Java compilers generally used are free to compile 
4608      * the expression into any byte codes they think efficient, making it too hard for the 
4609      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4610      * @param var A value or object.
4611      * @param other A value or object.
4612      * @return The logical OR of the two operands.
4613      * @since 1.0
4614      * @javascript Re-compilers must replace the static invocation of this method with the 
4615      * JavaScript expression:
4616      * <pre>var || other</pre>
4617      */
4618     public static final String or(String var, JsString other) { return be(var) ? var : valueOf(other);}
4619     /**
4620      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4621      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4622      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4623      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4624      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4625      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4626      * its first operand, the expression on its left. If the value of this expression can 
4627      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4628      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4629      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4630      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4631      * and doesn't return the unconverted value of the left-side expression.</p>
4632      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4633      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4634      * anonymously, returning the actual expression in the method overriding 
4635      * {@link Var#var()}.</p>
4636      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4637      * operands that include side effects, unless you purposely want to use the fact that 
4638      * the right-side expression may not be evaluated in JavaScript.</p>
4639      * <p>Even when this operation is used with operands that are not boolean values, it 
4640      * can still be considered a Boolean OR operator because its return value, whatever the 
4641      * type, can be converted to a boolean value.</p>
4642      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4643      * re-compilations. However, in most cases you can use the logical OR operator of the 
4644      * Java language like this:
4645      * <pre>Js.be(var) || Js.be(other)</pre>
4646      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4647      * JavaScript expression since the Java compilers generally used are free to compile 
4648      * the expression into any byte codes they think efficient, making it too hard for the 
4649      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4650      * @param var A value or object.
4651      * @param other A value or object.
4652      * @return The logical OR of the two operands.
4653      * @since 1.0
4654      * @javascript Re-compilers must replace the static invocation of this method with the 
4655      * JavaScript expression:
4656      * <pre>var || other</pre>
4657      */
4658     public static final String or(Var<String> var, JsString other) { return be(var) ? var.var() : valueOf(other);}
4659 
4660     /**
4661      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
4662      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
4663      * operand, otherwise.</p>
4664      * <p>The first operand of the conditional operation must be (or be convertible to) a 
4665      * boolean value. Usually this is the result of a comparison operation. The second and 
4666      * third operands may have any value. The value returned by the conditional operation 
4667      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
4668      * the value of the conditional expression is the value of the second operand. If the 
4669      * first operand is <tt>false</tt>, the value of the conditional expression is the 
4670      * value of the third operand.</p>
4671      * <p>To make the second and third operands really late-evaluated or not evaluated in 
4672      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
4673      * {@link Var} anonymously, returning the actual expression in the method overriding 
4674      * {@link Var#var()}.</p>
4675      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4676      * re-compilations. However, in most cases you can use the conditional operator of the 
4677      * Java language like this:
4678      * <pre>Js.be(test) ? var : other</pre>
4679      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4680      * JavaScript expression since the Java compilers generally used are free to compile 
4681      * the expression into any byte codes they think efficient, making it too hard for the 
4682      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4683      * @param var A value or object.
4684      * @param other A value or object.
4685      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
4686      * the third operand.
4687      * @since 1.0
4688      * @javascript Re-compilers must replace the static invocation of this method with the 
4689      * JavaScript expression:
4690      * <pre>test ? var : other</pre>
4691      */
4692     public static final <T> T cond(Object test, T var, T other) { return be(test) ? var : other;}
4693     /**
4694      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
4695      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
4696      * operand, otherwise.</p>
4697      * <p>The first operand of the conditional operation must be (or be convertible to) a 
4698      * boolean value. Usually this is the result of a comparison operation. The second and 
4699      * third operands may have any value. The value returned by the conditional operation 
4700      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
4701      * the value of the conditional expression is the value of the second operand. If the 
4702      * first operand is <tt>false</tt>, the value of the conditional expression is the 
4703      * value of the third operand.</p>
4704      * <p>To make the second and third operands really late-evaluated or not evaluated in 
4705      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
4706      * {@link Var} anonymously, returning the actual expression in the method overriding 
4707      * {@link Var#var()}.</p>
4708      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4709      * re-compilations. However, in most cases you can use the conditional operator of the 
4710      * Java language like this:
4711      * <pre>Js.be(test) ? var : other</pre>
4712      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4713      * JavaScript expression since the Java compilers generally used are free to compile 
4714      * the expression into any byte codes they think efficient, making it too hard for the 
4715      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4716      * @param var A value or object.
4717      * @param other A value or object.
4718      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
4719      * the third operand.
4720      * @since 1.0
4721      * @javascript Re-compilers must replace the static invocation of this method with the 
4722      * JavaScript expression:
4723      * <pre>test ? var : other</pre>
4724      */
4725     public static final <T> T cond(Object test, Var<? extends T> var, T other) {
4726         return be(test) ? (var == null ? (T)null : var.var()) : other;
4727     }
4728     /**
4729      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
4730      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
4731      * operand, otherwise.</p>
4732      * <p>The first operand of the conditional operation must be (or be convertible to) a 
4733      * boolean value. Usually this is the result of a comparison operation. The second and 
4734      * third operands may have any value. The value returned by the conditional operation 
4735      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
4736      * the value of the conditional expression is the value of the second operand. If the 
4737      * first operand is <tt>false</tt>, the value of the conditional expression is the 
4738      * value of the third operand.</p>
4739      * <p>To make the second and third operands really late-evaluated or not evaluated in 
4740      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
4741      * {@link Var} anonymously, returning the actual expression in the method overriding 
4742      * {@link Var#var()}.</p>
4743      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4744      * re-compilations. However, in most cases you can use the conditional operator of the 
4745      * Java language like this:
4746      * <pre>Js.be(test) ? var : other</pre>
4747      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4748      * JavaScript expression since the Java compilers generally used are free to compile 
4749      * the expression into any byte codes they think efficient, making it too hard for the 
4750      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4751      * @param var A value or object.
4752      * @param other A value or object.
4753      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
4754      * the third operand.
4755      * @since 1.0
4756      * @javascript Re-compilers must replace the static invocation of this method with the 
4757      * JavaScript expression:
4758      * <pre>test ? var : other</pre>
4759      */
4760     public static final <T> T cond(Object test, T var, Var<? extends T> other) {
4761         return be(test) ? var : other == null ? (T)null : other.var();
4762     }
4763     /**
4764      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
4765      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
4766      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
4767      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
4768      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
4769      * may or may not evaluate the right-side expression. The actual behavior of the operator 
4770      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
4771      * on its left. If the value of this expression can be converted to <tt>false</tt> 
4772      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
4773      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
4774      * its second operand, the expression on its right, and returns the value of that 
4775      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
4776      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
4777      * returning the unconverted value of the left-side expression.</p>
4778      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4779      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4780      * anonymously, returning the actual expression in the method overriding 
4781      * {@link Var#var()}.</p>
4782      * <p>Sometimes, this operation probably does not do what the programmers intended. 
4783      * To avoid problems, do not use expressions with side effects (assignments, increments, 
4784      * decrements, and function calls) for the second operand unless you are quite sure 
4785      * you know exactly what you are doing.</p>
4786      * <p>Despite the fairly confusing way that this operation actually works, it is 
4787      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
4788      * Although it does not actually return a boolean value, the value it returns can always 
4789      * be converted to a boolean value.</p>
4790      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4791      * re-compilations. However, in most cases you can use the logical AND operator of the 
4792      * Java language like this:
4793      * <pre>Js.be(var) && Js.be(other)</pre>
4794      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4795      * JavaScript expression since the Java compilers generally used are free to compile 
4796      * the expression into any byte codes they think efficient, making it too hard for the 
4797      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4798      * @param var A value or object.
4799      * @param other A value or object.
4800      * @return The logical AND of the two operands.
4801      * @since 1.0
4802      * @javascript Re-compilers must replace the static invocation of this method with the 
4803      * JavaScript expression:
4804      * <pre>var && other</pre>
4805      */
4806     public static final <T extends JsObject> T and(T var, T other) { return not(var) ? var : other;}
4807     /**
4808      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
4809      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
4810      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
4811      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
4812      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
4813      * may or may not evaluate the right-side expression. The actual behavior of the operator 
4814      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
4815      * on its left. If the value of this expression can be converted to <tt>false</tt> 
4816      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
4817      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
4818      * its second operand, the expression on its right, and returns the value of that 
4819      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
4820      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
4821      * returning the unconverted value of the left-side expression.</p>
4822      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4823      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4824      * anonymously, returning the actual expression in the method overriding 
4825      * {@link Var#var()}.</p>
4826      * <p>Sometimes, this operation probably does not do what the programmers intended. 
4827      * To avoid problems, do not use expressions with side effects (assignments, increments, 
4828      * decrements, and function calls) for the second operand unless you are quite sure 
4829      * you know exactly what you are doing.</p>
4830      * <p>Despite the fairly confusing way that this operation actually works, it is 
4831      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
4832      * Although it does not actually return a boolean value, the value it returns can always 
4833      * be converted to a boolean value.</p>
4834      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4835      * re-compilations. However, in most cases you can use the logical AND operator of the 
4836      * Java language like this:
4837      * <pre>Js.be(var) && Js.be(other)</pre>
4838      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4839      * JavaScript expression since the Java compilers generally used are free to compile 
4840      * the expression into any byte codes they think efficient, making it too hard for the 
4841      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4842      * @param var A value or object.
4843      * @param other A value or object.
4844      * @return The logical AND of the two operands.
4845      * @since 1.0
4846      * @javascript Re-compilers must replace the static invocation of this method with the 
4847      * JavaScript expression:
4848      * <pre>var && other</pre>
4849      */
4850     public static final <T extends JsObject> T and(Var<? extends T> var, T other) {
4851         if (var == null) return (T)null;
4852         T v = var.var();
4853         return not(v) ? v : other;
4854     }
4855     /**
4856      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
4857      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
4858      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
4859      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
4860      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
4861      * may or may not evaluate the right-side expression. The actual behavior of the operator 
4862      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
4863      * on its left. If the value of this expression can be converted to <tt>false</tt> 
4864      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
4865      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
4866      * its second operand, the expression on its right, and returns the value of that 
4867      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
4868      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
4869      * returning the unconverted value of the left-side expression.</p>
4870      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4871      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4872      * anonymously, returning the actual expression in the method overriding 
4873      * {@link Var#var()}.</p>
4874      * <p>Sometimes, this operation probably does not do what the programmers intended. 
4875      * To avoid problems, do not use expressions with side effects (assignments, increments, 
4876      * decrements, and function calls) for the second operand unless you are quite sure 
4877      * you know exactly what you are doing.</p>
4878      * <p>Despite the fairly confusing way that this operation actually works, it is 
4879      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
4880      * Although it does not actually return a boolean value, the value it returns can always 
4881      * be converted to a boolean value.</p>
4882      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4883      * re-compilations. However, in most cases you can use the logical AND operator of the 
4884      * Java language like this:
4885      * <pre>Js.be(var) && Js.be(other)</pre>
4886      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4887      * JavaScript expression since the Java compilers generally used are free to compile 
4888      * the expression into any byte codes they think efficient, making it too hard for the 
4889      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4890      * @param var A value or object.
4891      * @param other A value or object.
4892      * @return The logical AND of the two operands.
4893      * @since 1.0
4894      * @javascript Re-compilers must replace the static invocation of this method with the 
4895      * JavaScript expression:
4896      * <pre>var && other</pre>
4897      */
4898     public static final <T extends JsObject> T and(T var, Var<? extends T> other) {
4899         return not(var) ? var : other == null ? (T)null : other.var();
4900     }
4901     /**
4902      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
4903      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
4904      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
4905      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
4906      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
4907      * may or may not evaluate the right-side expression. The actual behavior of the operator 
4908      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
4909      * on its left. If the value of this expression can be converted to <tt>false</tt> 
4910      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
4911      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
4912      * its second operand, the expression on its right, and returns the value of that 
4913      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
4914      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
4915      * returning the unconverted value of the left-side expression.</p>
4916      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4917      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4918      * anonymously, returning the actual expression in the method overriding 
4919      * {@link Var#var()}.</p>
4920      * <p>Sometimes, this operation probably does not do what the programmers intended. 
4921      * To avoid problems, do not use expressions with side effects (assignments, increments, 
4922      * decrements, and function calls) for the second operand unless you are quite sure 
4923      * you know exactly what you are doing.</p>
4924      * <p>Despite the fairly confusing way that this operation actually works, it is 
4925      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
4926      * Although it does not actually return a boolean value, the value it returns can always 
4927      * be converted to a boolean value.</p>
4928      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4929      * re-compilations. However, in most cases you can use the logical AND operator of the 
4930      * Java language like this:
4931      * <pre>Js.be(var) && Js.be(other)</pre>
4932      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4933      * JavaScript expression since the Java compilers generally used are free to compile 
4934      * the expression into any byte codes they think efficient, making it too hard for the 
4935      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4936      * @param var A value or object.
4937      * @param other A value or object.
4938      * @return The logical AND of the two operands.
4939      * @since 1.0
4940      * @javascript Re-compilers must replace the static invocation of this method with the 
4941      * JavaScript expression:
4942      * <pre>var && other</pre>
4943      */
4944     public static final <T> T and(Var<? extends T> var, Var<? extends T> other) {
4945         if (var == null) return (T)null;
4946         T v = var.var();
4947         return not(v) ? v : other == null ? (T)null : other.var();
4948     }
4949     /**
4950      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4951      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4952      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4953      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4954      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4955      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4956      * its first operand, the expression on its left. If the value of this expression can 
4957      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4958      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4959      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
4960      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
4961      * and doesn't return the unconverted value of the left-side expression.</p>
4962      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
4963      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
4964      * anonymously, returning the actual expression in the method overriding 
4965      * {@link Var#var()}.</p>
4966      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
4967      * operands that include side effects, unless you purposely want to use the fact that 
4968      * the right-side expression may not be evaluated in JavaScript.</p>
4969      * <p>Even when this operation is used with operands that are not boolean values, it 
4970      * can still be considered a Boolean OR operator because its return value, whatever the 
4971      * type, can be converted to a boolean value.</p>
4972      * <p>Note that, this method is probably useful in emulation codes just for perfect 
4973      * re-compilations. However, in most cases you can use the logical OR operator of the 
4974      * Java language like this:
4975      * <pre>Js.be(var) || Js.be(other)</pre>
4976      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
4977      * JavaScript expression since the Java compilers generally used are free to compile 
4978      * the expression into any byte codes they think efficient, making it too hard for the 
4979      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
4980      * @param var A value or object.
4981      * @param other A value or object.
4982      * @return The logical OR of the two operands.
4983      * @since 1.0
4984      * @javascript Re-compilers must replace the static invocation of this method with the 
4985      * JavaScript expression:
4986      * <pre>var || other</pre>
4987      */
4988     public static final <T extends JsObject> T or(T var, T other) { return be(var) ? var : other;}
4989     /**
4990      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
4991      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
4992      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
4993      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
4994      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
4995      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
4996      * its first operand, the expression on its left. If the value of this expression can 
4997      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
4998      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
4999      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
5000      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
5001      * and doesn't return the unconverted value of the left-side expression.</p>
5002      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
5003      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
5004      * anonymously, returning the actual expression in the method overriding 
5005      * {@link Var#var()}.</p>
5006      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
5007      * operands that include side effects, unless you purposely want to use the fact that 
5008      * the right-side expression may not be evaluated in JavaScript.</p>
5009      * <p>Even when this operation is used with operands that are not boolean values, it 
5010      * can still be considered a Boolean OR operator because its return value, whatever the 
5011      * type, can be converted to a boolean value.</p>
5012      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5013      * re-compilations. However, in most cases you can use the logical OR operator of the 
5014      * Java language like this:
5015      * <pre>Js.be(var) || Js.be(other)</pre>
5016      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5017      * JavaScript expression since the Java compilers generally used are free to compile 
5018      * the expression into any byte codes they think efficient, making it too hard for the 
5019      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5020      * @param var A value or object.
5021      * @param other A value or object.
5022      * @return The logical OR of the two operands.
5023      * @since 1.0
5024      * @javascript Re-compilers must replace the static invocation of this method with the 
5025      * JavaScript expression:
5026      * <pre>var || other</pre>
5027      */
5028     public static final <T extends JsObject> T or(Var<? extends T> var, T other) {
5029         T v = var == null ? (T)null : var.var();
5030         return be(v) ? v : other;
5031     }
5032     /**
5033      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
5034      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
5035      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
5036      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
5037      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
5038      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
5039      * its first operand, the expression on its left. If the value of this expression can 
5040      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
5041      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
5042      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
5043      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
5044      * and doesn't return the unconverted value of the left-side expression.</p>
5045      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
5046      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
5047      * anonymously, returning the actual expression in the method overriding 
5048      * {@link Var#var()}.</p>
5049      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
5050      * operands that include side effects, unless you purposely want to use the fact that 
5051      * the right-side expression may not be evaluated in JavaScript.</p>
5052      * <p>Even when this operation is used with operands that are not boolean values, it 
5053      * can still be considered a Boolean OR operator because its return value, whatever the 
5054      * type, can be converted to a boolean value.</p>
5055      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5056      * re-compilations. However, in most cases you can use the logical OR operator of the 
5057      * Java language like this:
5058      * <pre>Js.be(var) || Js.be(other)</pre>
5059      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5060      * JavaScript expression since the Java compilers generally used are free to compile 
5061      * the expression into any byte codes they think efficient, making it too hard for the 
5062      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5063      * @param var A value or object.
5064      * @param other A value or object.
5065      * @return The logical OR of the two operands.
5066      * @since 1.0
5067      * @javascript Re-compilers must replace the static invocation of this method with the 
5068      * JavaScript expression:
5069      * <pre>var || other</pre>
5070      */
5071     public static final <T extends JsObject> T or(T var, Var<? extends T> other) {
5072         return be(var) ? var : other == null ? (T)null : other.var();
5073     }
5074     /**
5075      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
5076      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
5077      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
5078      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
5079      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
5080      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
5081      * its first operand, the expression on its left. If the value of this expression can 
5082      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
5083      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
5084      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
5085      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
5086      * and doesn't return the unconverted value of the left-side expression.</p>
5087      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
5088      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
5089      * anonymously, returning the actual expression in the method overriding 
5090      * {@link Var#var()}.</p>
5091      * <p>As with the {@link #and(Object, Object)} operation, you should avoid right-side 
5092      * operands that include side effects, unless you purposely want to use the fact that 
5093      * the right-side expression may not be evaluated in JavaScript.</p>
5094      * <p>Even when this operation is used with operands that are not boolean values, it 
5095      * can still be considered a Boolean OR operator because its return value, whatever the 
5096      * type, can be converted to a boolean value.</p>
5097      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5098      * re-compilations. However, in most cases you can use the logical OR operator of the 
5099      * Java language like this:
5100      * <pre>Js.be(var) || Js.be(other)</pre>
5101      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5102      * JavaScript expression since the Java compilers generally used are free to compile 
5103      * the expression into any byte codes they think efficient, making it too hard for the 
5104      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5105      * @param var A value or object.
5106      * @param other A value or object.
5107      * @return The logical OR of the two operands.
5108      * @since 1.0
5109      * @javascript Re-compilers must replace the static invocation of this method with the 
5110      * JavaScript expression:
5111      * <pre>var || other</pre>
5112      */
5113     public static final <T> T or(Var<? extends T> var, Var<? extends T> other) {
5114         T v = var == null ? (T)null : var.var();
5115         return be(v) ? v : other == null ? (T)null : other.var();
5116     }
5117     /**
5118      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
5119      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
5120      * operand, otherwise.</p>
5121      * <p>The first operand of the conditional operation must be (or be convertible to) a 
5122      * boolean value. Usually this is the result of a comparison operation. The second and 
5123      * third operands may have any value. The value returned by the conditional operation 
5124      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
5125      * the value of the conditional expression is the value of the second operand. If the 
5126      * first operand is <tt>false</tt>, the value of the conditional expression is the 
5127      * value of the third operand.</p>
5128      * <p>To make the second and third operands really late-evaluated or not evaluated in 
5129      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
5130      * {@link Var} anonymously, returning the actual expression in the method overriding 
5131      * {@link Var#var()}.</p>
5132      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5133      * re-compilations. However, in most cases you can use the conditional operator of the 
5134      * Java language like this:
5135      * <pre>Js.be(test) ? var : other</pre>
5136      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5137      * JavaScript expression since the Java compilers generally used are free to compile 
5138      * the expression into any byte codes they think efficient, making it too hard for the 
5139      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5140      * @param var A value or object.
5141      * @param other A value or object.
5142      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
5143      * the third operand.
5144      * @since 1.0
5145      * @javascript Re-compilers must replace the static invocation of this method with the 
5146      * JavaScript expression:
5147      * <pre>test ? var : other</pre>
5148      */
5149     public static final <T extends JsObject> T cond(Object test, T var, T other) { return be(test) ? var : other;}
5150     /**
5151      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
5152      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
5153      * operand, otherwise.</p>
5154      * <p>The first operand of the conditional operation must be (or be convertible to) a 
5155      * boolean value. Usually this is the result of a comparison operation. The second and 
5156      * third operands may have any value. The value returned by the conditional operation 
5157      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
5158      * the value of the conditional expression is the value of the second operand. If the 
5159      * first operand is <tt>false</tt>, the value of the conditional expression is the 
5160      * value of the third operand.</p>
5161      * <p>To make the second and third operands really late-evaluated or not evaluated in 
5162      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
5163      * {@link Var} anonymously, returning the actual expression in the method overriding 
5164      * {@link Var#var()}.</p>
5165      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5166      * re-compilations. However, in most cases you can use the conditional operator of the 
5167      * Java language like this:
5168      * <pre>Js.be(test) ? var : other</pre>
5169      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5170      * JavaScript expression since the Java compilers generally used are free to compile 
5171      * the expression into any byte codes they think efficient, making it too hard for the 
5172      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5173      * @param var A value or object.
5174      * @param other A value or object.
5175      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
5176      * the third operand.
5177      * @since 1.0
5178      * @javascript Re-compilers must replace the static invocation of this method with the 
5179      * JavaScript expression:
5180      * <pre>test ? var : other</pre>
5181      */
5182     public static final <T extends JsObject> T cond(Object test, Var<? extends T> var, T other) {
5183         return be(test) ? (var == null ? (T)null : var.var()) : other;
5184     }
5185     /**
5186      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
5187      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
5188      * operand, otherwise.</p>
5189      * <p>The first operand of the conditional operation must be (or be convertible to) a 
5190      * boolean value. Usually this is the result of a comparison operation. The second and 
5191      * third operands may have any value. The value returned by the conditional operation 
5192      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
5193      * the value of the conditional expression is the value of the second operand. If the 
5194      * first operand is <tt>false</tt>, the value of the conditional expression is the 
5195      * value of the third operand.</p>
5196      * <p>To make the second and third operands really late-evaluated or not evaluated in 
5197      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
5198      * {@link Var} anonymously, returning the actual expression in the method overriding 
5199      * {@link Var#var()}.</p>
5200      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5201      * re-compilations. However, in most cases you can use the conditional operator of the 
5202      * Java language like this:
5203      * <pre>Js.be(test) ? var : other</pre>
5204      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5205      * JavaScript expression since the Java compilers generally used are free to compile 
5206      * the expression into any byte codes they think efficient, making it too hard for the 
5207      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5208      * @param var A value or object.
5209      * @param other A value or object.
5210      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
5211      * the third operand.
5212      * @since 1.0
5213      * @javascript Re-compilers must replace the static invocation of this method with the 
5214      * JavaScript expression:
5215      * <pre>test ? var : other</pre>
5216      */
5217     public static final <T extends JsObject> T cond(Object test, T var, Var<? extends T> other) {
5218         return be(test) ? var : other == null ? (T)null : other.var();
5219     }
5220     /**
5221      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
5222      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
5223      * operand, otherwise.</p>
5224      * <p>The first operand of the conditional operation must be (or be convertible to) a 
5225      * boolean value. Usually this is the result of a comparison operation. The second and 
5226      * third operands may have any value. The value returned by the conditional operation 
5227      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
5228      * the value of the conditional expression is the value of the second operand. If the 
5229      * first operand is <tt>false</tt>, the value of the conditional expression is the 
5230      * value of the third operand.</p>
5231      * <p>To make the second and third operands really late-evaluated or not evaluated in 
5232      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
5233      * {@link Var} anonymously, returning the actual expression in the method overriding 
5234      * {@link Var#var()}.</p>
5235      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5236      * re-compilations. However, in most cases you can use the conditional operator of the 
5237      * Java language like this:
5238      * <pre>Js.be(test) ? var : other</pre>
5239      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
5240      * JavaScript expression since the Java compilers generally used are free to compile 
5241      * the expression into any byte codes they think efficient, making it too hard for the 
5242      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
5243      * @param var A value or object.
5244      * @param other A value or object.
5245      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
5246      * the third operand.
5247      * @since 1.0
5248      * @javascript Re-compilers must replace the static invocation of this method with the 
5249      * JavaScript expression:
5250      * <pre>test ? var : other</pre>
5251      */
5252     public static final <T> T cond(Object test, Var<? extends T> var, Var<? extends T> other) {
5253         return be(test) ? (var == null ? (T)null : var.var()) : (other == null ? (T)null : other.var());
5254     }
5255 
5256     /**
5257      * <p>Comma operation, resembling the comma operator of JavaScript, evaluates the 
5258      * first operand, evaluates the second operand, and then returns the value of the 
5259      * second operand.</p>
5260      * <p>In JavaScript, this strange operator is useful only in a few limited circumstances, 
5261      * primarily when you need to evaluate several independent expressions with side effects 
5262      * in a situation where only a single expression is allowed. In practice, the comma 
5263      * operator is really used only in conjunction with the <tt>for</tt> loop statement.</p>
5264      * <p>Note that, this method is probably useful in emulation codes just for perfect 
5265      * re-compilations.</p>
5266      * @param var A value or object.
5267      * @param other A value or object.
5268      * @return The second operand.
5269      * @since 1.0
5270      * @javascript Re-compilers must replace the static invocation of this method with the 
5271      * JavaScript expression:
5272      * <pre>var, other</pre>
5273      */
5274     public static final <T> T comma(Object var, T other) { valueOf(var); return other;}
5275 
5276     /**
5277      * <p>Performs unary negation on a 64-bit integer.</p>
5278      * <p>This operation converts a positive value to an equivalently negative value, and 
5279      * vice versa. If the operand is not a 64-bit integer, it attempts to convert it to one.</p>
5280      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5281      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5282      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5283      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5284      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5285      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5286      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5287      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5288      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5289      * bits involve the invocation of a predefined re-compiler dependent function while 
5290      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5291      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5292      * string representation of the <tt>long</tt> number in full 64-bit precision. </p>
5293      * @param var Any numeric value.
5294      * @return The negation of the 64-bit integer.
5295      * @since 1.0
5296      * @javascript A re-compiler is expected to replace the static invocation of this method 
5297      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5298      * the same re-compiler would replace the byte codes of a negation operation on a long number, 
5299      * such as the byte codes compiled from the following Java expression:  
5300      * <pre>-((Number)var).longValue()</pre>
5301      */
5302     public static final long lneg(Object var) { return s().neg(s().getNumber(var)).longValue();}
5303     /**
5304      * <p>The 64-bit bitwise-NOT operation, casting the operand to a <tt>long</tt> number 
5305      * if it is not 64-bit, operates by reversing all bits in the 64-bit integer.</p>
5306      * <p>Because of the way signed integers are represented in JavaScript, applying this 
5307      * operation to a value is equivalent to changing its sign and subtracting 1.</p>
5308      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5309      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5310      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5311      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5312      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5313      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5314      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5315      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5316      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5317      * bits involve the invocation of a predefined re-compiler dependent function while 
5318      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5319      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5320      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5321      * @param var Any numeric value.
5322      * @return The bitwise-NOT of the 64-bit integer.
5323      * @since 1.0
5324      * @javascript A re-compiler is expected to replace the static invocation of this method 
5325      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5326      * the same re-compiler would replace the byte codes of a bitwise-NOT operation on a long number, 
5327      * such as the byte codes compiled from the following Java expression:  
5328      * <pre>~((Number)var).longValue()</pre>
5329      */
5330     public static final long lnot(Object var) { return ~s().getNumber(var).longValue();}
5331     /**
5332      * <p>Adds two 64-bit integers, casting the operands to <tt>long</tt> numbers if any 
5333      * one of them is not a 64-bit integer.</p>
5334      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5335      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5336      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5337      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5338      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5339      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5340      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5341      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5342      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5343      * bits involve the invocation of a predefined re-compiler dependent function while 
5344      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5345      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5346      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5347      * @param var Any numeric value.
5348      * @param other Any numeric value.
5349      * @return The sum of the two 64-bit integers.
5350      * @since 1.0
5351      * @javascript A re-compiler is expected to replace the static invocation of this method 
5352      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5353      * the same re-compiler would replace the byte codes of an addition operation on two long numbers, 
5354      * such as the byte codes compiled from the following Java expression:  
5355      * <pre>((Number)var).longValue() + ((Number)other).longValue()</pre>
5356      */
5357     public static final long ladd(Object var, Object other) { return s().getNumber(var).longValue() + s().getNumber(other).longValue();}
5358     /**
5359      * <p>Subtracts the second 64-bit integer from the first 64-bit integer, casting the 
5360      * operands to <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
5361      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5362      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5363      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5364      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5365      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5366      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5367      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5368      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5369      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5370      * bits involve the invocation of a predefined re-compiler dependent function while 
5371      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5372      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5373      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5374      * @param var Any numeric value.
5375      * @param other Any numeric value.
5376      * @return The difference between the two 64-bit integers.
5377      * @since 1.0
5378      * @javascript A re-compiler is expected to replace the static invocation of this method 
5379      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5380      * the same re-compiler would replace the byte codes of a subtraction operation on two long numbers, 
5381      * such as the byte codes compiled from the following Java expression:  
5382      * <pre>((Number)var).longValue() - ((Number)other).longValue()</pre>
5383      */
5384     public static final long lsub(Object var, Object other) { return s().getNumber(var).longValue() - s().getNumber(other).longValue();}
5385     /**
5386      * <p>Multiplies the two 64-bit integer, casting the operands to <tt>long</tt> numbers 
5387      * if any one of them is not a 64-bit integer.</p>
5388      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5389      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5390      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5391      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5392      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5393      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5394      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5395      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5396      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5397      * bits involve the invocation of a predefined re-compiler dependent function while 
5398      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5399      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5400      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5401      * @param var Any numeric value.
5402      * @param other Any numeric value.
5403      * @return The product of the two 64-bit integers.
5404      * @since 1.0
5405      * @javascript A re-compiler is expected to replace the static invocation of this method 
5406      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5407      * the same re-compiler would replace the byte codes of a multiplication operation on two long numbers, 
5408      * such as the byte codes compiled from the following Java expression:  
5409      * <pre>((Number)var).longValue() * ((Number)other).longValue()</pre>
5410      */
5411     public static final long lmul(Object var, Object other) { return s().getNumber(var).longValue() * s().getNumber(other).longValue();}
5412     /**
5413      * <p>Divides the first 64-bit integer by the second 64-bit integer, casting the operands 
5414      * to <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
5415      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5416      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5417      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5418      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5419      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5420      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5421      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5422      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5423      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5424      * bits involve the invocation of a predefined re-compiler dependent function while 
5425      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5426      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5427      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5428      * @param var Any numeric value.
5429      * @param other Any numeric value.
5430      * @return The quotient of the two 64-bit integers.
5431      * @since 1.0
5432      * @javascript A re-compiler is expected to replace the static invocation of this method 
5433      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5434      * the same re-compiler would replace the byte codes of an division operation on two long numbers, 
5435      * such as the byte codes compiled from the following Java expression:  
5436      * <pre>((Number)var).longValue() / ((Number)other).longValue()</pre>
5437      */
5438     public static final long ldiv(Object var, Object other) { return s().getNumber(var).longValue() / s().getNumber(other).longValue();}
5439     /**
5440      * <p>Computes the first operand modulo the second operand, casting the operands to 
5441      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
5442      * <p>The operation returns the remainder when the first operand is divided by the 
5443      * second operand a certain number of times. The sign of the result is the same as the 
5444      * sign of the first operand.</p>
5445      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5446      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5447      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5448      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5449      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5450      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5451      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5452      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5453      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5454      * bits involve the invocation of a predefined re-compiler dependent function while 
5455      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5456      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5457      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5458      * @param var Any numeric value.
5459      * @param other Any numeric value.
5460      * @return The remainder.
5461      * @since 1.0
5462      * @javascript A re-compiler is expected to replace the static invocation of this method 
5463      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5464      * the same re-compiler would replace the byte codes of a modulo operation on two long numbers, 
5465      * such as the byte codes compiled from the following Java expression:  
5466      * <pre>((Number)var).longValue() % ((Number)other).longValue()</pre>
5467      */
5468     public static final long lmod(Object var, Object other) { return s().getNumber(var).longValue() % s().getNumber(other).longValue();}
5469     /**
5470      * <p>The 64-bit shift-left operation, casting the first operand to a <tt>long</tt> 
5471      * number if it is not 64-bit, moves all bits in it to the left by the number of places 
5472      * specified in the second operand, which should be an integer between 0 and 63.</p>
5473      * <p>A zero is used for the new first bit, and the value of the 64th bit is lost. 
5474      * Shifting a value left by one position is equivalent to multiplying by 2, shifting 
5475      * two positions is equivalent to multiplying by 4, etc.</p>
5476      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5477      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5478      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5479      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5480      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5481      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5482      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5483      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5484      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5485      * bits involve the invocation of a predefined re-compiler dependent function while 
5486      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5487      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5488      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5489      * @param var Any numeric value.
5490      * @param n The number of bits to shift.
5491      * @return The shifted 64-bit integer.
5492      * @since 1.0
5493      * @javascript A re-compiler is expected to replace the static invocation of this method 
5494      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5495      * the same re-compiler would replace the byte codes of a shift-left operation on a long number, 
5496      * such as the byte codes compiled from the following Java expression:  
5497      * <pre>((Number)var).longValue() << n</pre>
5498      */
5499     public static final long lshl (Object var, int n) { return s().getNumber(var).longValue() << n;}
5500     /**
5501      * <p>The 64-bit shift-right operation, casting the first operand to a <tt>long</tt> 
5502      * number if it is not 64-bit, moves all bits in it to the right by the number of 
5503      * places specified in the second operand (an integer between 0 and 63). Bits that are 
5504      * shifted off the right are lost. The bits filled in on the left depend on the sign 
5505      * bit of the original operand, in order to preserve the sign of the result. If the 
5506      * first operand is positive, the result has zeros placed in the high bits; if the 
5507      * first operand is negative, the result has ones placed in the high bits.</p>
5508      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
5509      * remainder), shifting right two places is equivalent to integer division by 4, and 
5510      * so on.</p>
5511      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5512      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5513      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5514      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5515      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5516      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5517      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5518      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5519      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5520      * bits involve the invocation of a predefined re-compiler dependent function while 
5521      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5522      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5523      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5524      * @param var Any numeric value.
5525      * @param n The number of bits to shift.
5526      * @return The shifted 64-bit integer.
5527      * @since 1.0
5528      * @javascript A re-compiler is expected to replace the static invocation of this method 
5529      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5530      * the same re-compiler would replace the byte codes of a shift-right operation on a long number, 
5531      * such as the byte codes compiled from the following Java expression:  
5532      * <pre>((Number)var).longValue() >> n</pre>
5533      */
5534     public static final long lshr (Object var, int n) { return s().getNumber(var).longValue() >> n;}
5535     /**
5536      * <p>The 64-bit shift-right-unsigned operation, casting the first operand to a 
5537      * <tt>long</tt> number if it is not 64-bit, moves all bits in it to the right by the 
5538      * number of places specified in the second operand (an integer between 0 and 63). Bits 
5539      * that are shifted off the right are lost. The result has zeros placed in the high 
5540      * bits.</p>
5541      * <p>This operation is just like {@link #lshr(Object, int)}, except that the bits shifted 
5542      * in on the left are always zero, regardless of the sign of the first operand.</p>
5543      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
5544      * remainder), shifting right two places is equivalent to integer division by 4, and 
5545      * so on.</p>
5546      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5547      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5548      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5549      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5550      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5551      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5552      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5553      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5554      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5555      * bits involve the invocation of a predefined re-compiler dependent function while 
5556      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5557      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5558      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5559      * @param var Any numeric value.
5560      * @param n The number of bits to shift.
5561      * @return The shifted 64-bit integer.
5562      * @since 1.0
5563      * @javascript A re-compiler is expected to replace the static invocation of this method 
5564      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5565      * the same re-compiler would replace the byte codes of an unsigned shift-right operation on a long number, 
5566      * such as the byte codes compiled from the following Java expression:  
5567      * <pre>((Number)var).longValue() >>> n</pre>
5568      */
5569     public static final long lshru(Object var, int n) { return s().getNumber(var).longValue() >>> n;}
5570     /**
5571      * <p>The 64-bit bitwise-AND operation, casting the operands to <tt>long</tt> numbers 
5572      * if any one of them is not a 64-bit integer, performs a boolean AND operation on each 
5573      * bit of the 64-bit integers. A bit is set in the result only if the corresponding 
5574      * bit is set in both operands.</p>
5575      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5576      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5577      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5578      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5579      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5580      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5581      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5582      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5583      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5584      * bits involve the invocation of a predefined re-compiler dependent function while 
5585      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5586      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5587      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5588      * @param var Any numeric value.
5589      * @param other Any numeric value.
5590      * @return The bitwise-AND of the two 64-bit integers.
5591      * @since 1.0
5592      * @javascript A re-compiler is expected to replace the static invocation of this method 
5593      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5594      * the same re-compiler would replace the byte codes of a bitwise AND operation on two long numbers, 
5595      * such as the byte codes compiled from the following Java expression:  
5596      * <pre>((Number)var).longValue() & ((Number)other).longValue()</pre>
5597      */
5598     public static final long land(Object var, Object other) { return s().getNumber(var).longValue() & s().getNumber(other).longValue();}
5599     /**
5600      * <p>The 64-bit bitwise-OR operation, casting the operands to <tt>long</tt> numbers if 
5601      * any one of them is not a 64-bit integer, performs a boolean OR operation on each bit 
5602      * of the 64-bit integers. A bit is set in the result if the corresponding bit is set 
5603      * in one or both of the operands.</p>
5604      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5605      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5606      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5607      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5608      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5609      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5610      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5611      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5612      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5613      * bits involve the invocation of a predefined re-compiler dependent function while 
5614      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5615      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5616      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5617      * @param var Any numeric value.
5618      * @param other Any numeric value.
5619      * @return The bitwise-OR of the two 64-bit integers.
5620      * @since 1.0
5621      * @javascript A re-compiler is expected to replace the static invocation of this method 
5622      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5623      * the same re-compiler would replace the byte codes of a bitwise OR operation on two long numbers, 
5624      * such as the byte codes compiled from the following Java expression:  
5625      * <pre>((Number)var).longValue() | ((Number)other).longValue()</pre>
5626      */
5627     public static final long lor (Object var, Object other) { return s().getNumber(var).longValue() | s().getNumber(other).longValue();}
5628     /**
5629      * <p>The 64-bit bitwise-XOR operation, casting the operands to <tt>long</tt> numbers 
5630      * if any one of them is not a 64-bit integer, performs a boolean exclusive OR operation 
5631      * on each bit of the 64-bit integers. Exclusive OR means that either operand one is 
5632      * <tt>true</tt> or operand two is <tt>true</tt>, but not both. A bit is set in this 
5633      * operation's result if a corresponding bit is set in one (but not both) of the two 
5634      * operands.</p>
5635      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5636      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5637      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5638      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5639      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5640      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5641      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5642      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5643      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5644      * bits involve the invocation of a predefined re-compiler dependent function while 
5645      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5646      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5647      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5648      * @param var Any numeric value.
5649      * @param other Any numeric value.
5650      * @return The bitwise-exclusive-OR of the two 64-bit integers.
5651      * @since 1.0
5652      * @javascript A re-compiler is expected to replace the static invocation of this method 
5653      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5654      * the same re-compiler would replace the byte codes of a bitwise exclusive OR operation on two long numbers, 
5655      * such as the byte codes compiled from the following Java expression:  
5656      * <pre>((Number)var).longValue() ^ ((Number)other).longValue()</pre>
5657      */
5658     public static final long lxor(Object var, Object other) { return s().getNumber(var).longValue() ^ s().getNumber(other).longValue();}
5659     /**
5660      * <p>The 64-bit less-than operation, casting the operands to <tt>long</tt> numbers if 
5661      * any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the first 
5662      * operand is less than the second operand; otherwise it evaluates to <tt>false</tt>.</p>
5663      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5664      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5665      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5666      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5667      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5668      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5669      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5670      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5671      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5672      * bits involve the invocation of a predefined re-compiler dependent function while 
5673      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5674      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5675      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5676      * @param var Any numeric value.
5677      * @param other Any numeric value.
5678      * @return <tt>true</tt> if the first operand is less than the second operand; 
5679      * otherwise <tt>false</tt>.
5680      * @since 1.0
5681      * @javascript A re-compiler is expected to replace the static invocation of this method 
5682      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5683      * the same re-compiler would replace the byte codes of a less-than operation on two long numbers, 
5684      * such as the byte codes compiled from the following Java expression:  
5685      * <pre>((Number)var).longValue() < ((Number)other).longValue()</pre>
5686      */
5687     public static final boolean llt (Object var, Object other) { return s().getNumber(var).longValue() <  s().getNumber(other).longValue();}
5688     /**
5689      * <p>The 64-bit greater-than operation, casting the operands to <tt>long</tt> numbers 
5690      * if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the first 
5691      * operand is greater than the second operand; otherwise it evaluates to <tt>false</tt>.</p>
5692      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5693      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5694      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5695      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5696      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5697      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5698      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5699      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5700      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5701      * bits involve the invocation of a predefined re-compiler dependent function while 
5702      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5703      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5704      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5705      * @param var Any numeric value.
5706      * @param other Any numeric value.
5707      * @return <tt>true</tt> if the first operand is greater than the second operand; 
5708      * otherwise <tt>false</tt>.
5709      * @since 1.0
5710      * @javascript A re-compiler is expected to replace the static invocation of this method 
5711      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5712      * the same re-compiler would replace the byte codes of a greater-than operation on two long numbers, 
5713      * such as the byte codes compiled from the following Java expression:  
5714      * <pre>((Number)var).longValue() > ((Number)other).longValue()</pre>
5715      */
5716     public static final boolean lgt (Object var, Object other) { return s().getNumber(var).longValue() >  s().getNumber(other).longValue();}
5717     /**
5718      * <p>The 64-bit less-than-or-equal operation, casting the operands to <tt>long</tt> 
5719      * numbers if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if 
5720      * the first operand is less than or equal to the second operand; otherwise it evaluates 
5721      * to <tt>false</tt>.</p>
5722      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5723      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5724      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5725      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5726      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5727      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5728      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5729      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5730      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5731      * bits involve the invocation of a predefined re-compiler dependent function while 
5732      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5733      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5734      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5735      * @param var Any numeric value.
5736      * @param other Any numeric value.
5737      * @return <tt>true</tt> if the first operand is less than or equal to the second operand; 
5738      * otherwise <tt>false</tt>.
5739      * @since 1.0
5740      * @javascript A re-compiler is expected to replace the static invocation of this method 
5741      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5742      * the same re-compiler would replace the byte codes of a less-than-or-equal operation on two long numbers, 
5743      * such as the byte codes compiled from the following Java expression:  
5744      * <pre>((Number)var).longValue() <= ((Number)other).longValue()</pre>
5745      */
5746     public static final boolean llte(Object var, Object other) { return s().getNumber(var).longValue() <= s().getNumber(other).longValue();}
5747     /**
5748      * <p>The 64-bit greater-than-or-equal operation, casting the operands to <tt>long</tt> 
5749      * numbers if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the 
5750      * first operand is greater than or equal to the second operand; otherwise it evaluates 
5751      * to <tt>false</tt>.</p>
5752      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5753      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5754      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5755      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5756      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5757      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5758      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5759      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5760      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5761      * bits involve the invocation of a predefined re-compiler dependent function while 
5762      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5763      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5764      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5765      * @param var Any numeric value.
5766      * @param other Any numeric value.
5767      * @return <tt>true</tt> if the first operand is greater than or equal to the second operand; 
5768      * otherwise <tt>false</tt>.
5769      * @since 1.0
5770      * @javascript A re-compiler is expected to replace the static invocation of this method 
5771      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5772      * the same re-compiler would replace the byte codes of a greater-than-or-equal operation on two long numbers, 
5773      * such as the byte codes compiled from the following Java expression:  
5774      * <pre>((Number)var).longValue() >= ((Number)other).longValue()</pre>
5775      */
5776     public static final boolean lgte(Object var, Object other) { return s().getNumber(var).longValue() >= s().getNumber(other).longValue();}
5777     /**
5778      * <p>Checks whether the two 64-bit integers are "equal", casting the operands to 
5779      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
5780      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5781      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5782      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5783      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5784      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5785      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5786      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5787      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5788      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5789      * bits involve the invocation of a predefined re-compiler dependent function while 
5790      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5791      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5792      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5793      * @param var Any numeric value.
5794      * @param other Any numeric value.
5795      * @return <tt>true</tt> if the first operand equals the second; <tt>false</tt>, 
5796      * otherwise;
5797      * @since 1.0
5798      * @javascript A re-compiler is expected to replace the static invocation of this method 
5799      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5800      * the same re-compiler would replace the byte codes of an equality operation on two long numbers, 
5801      * such as the byte codes compiled from the following Java expression:  
5802      * <pre>((Number)var).longValue() == ((Number)other).longValue()</pre>
5803      */
5804     public static final boolean leq (Object var, Object other) { return s().getNumber(var).longValue() == s().getNumber(other).longValue();}
5805     /**
5806      * <p>Checks whether the two 64-bit integers are not "equal", casting the operands to 
5807      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
5808      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
5809      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
5810      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
5811      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
5812      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
5813      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
5814      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
5815      * naturally evaluates to a normal number without extra casting codes. That is, casting 
5816      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
5817      * bits involve the invocation of a predefined re-compiler dependent function while 
5818      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
5819      * In addition, the <tt>toString()</tt> method of that object or array must return a 
5820      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
5821      * @param var Any numeric value.
5822      * @param other Any numeric value.
5823      * @return <tt>false</tt> if the first operand equals the second; <tt>true</tt>, 
5824      * otherwise;
5825      * @since 1.0
5826      * @javascript A re-compiler is expected to replace the static invocation of this method 
5827      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
5828      * the same re-compiler would replace the byte codes of an inequality operation on two long numbers, 
5829      * such as the byte codes compiled from the following Java expression:  
5830      * <pre>((Number)var).longValue() != ((Number)other).longValue()</pre>
5831      */
5832     public static final boolean lneq(Object var, Object other) { return s().getNumber(var).longValue() != s().getNumber(other).longValue();}
5833 }