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.core;
0021 
0022 import js.*;
0023 
0024 /**
0025  * <p>An <b>opaque</b> class representing JavaScript date objects.</p>
0026  *
0027  * @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>
0028  * 
0029  * @javascript <b>Opaque</b> types can be resolved but no class objects for them can be 
0030  * generated into the target codes. Re-compilers must exit with error on the operations of 
0031  * accessing that kind of class objects.
0032  * The <tt>checkcast</tt> operation to the class literal of this interface must be ignored 
0033  * and <tt>instanceof</tt> to it always <tt>true</tt>.
0034  */
0035 public class JsDate extends JsGlobal.Date.Prototype implements DateLike
0036 {
0037     /**
0038      * <p>An <b>opaque</b> class representing members of its enclosing <b>opaque</b> type.</p>
0039      * <p>Note that, this class is <b>opaque</b> but its constructors are all <b>internal</b>. 
0040      * This class and the subclasses of this class are used to declare either <b>opaque</b> 
0041      * <tt>public</tt> instance fields of the opaque type {@link js.Var.Member} or the 
0042      * <b>opaque</b> <tt>public</tt> static fields of other <b>opaque</b> types while their 
0043      * constructors are used to define the fields inside <b>opaque</b> classes. Under 
0044      * either circumstance, the field names must be exactly same as the member names, as 
0045      * the <b>opaque</b> fields of <b>opaque</b> types are resolved by re-compilers directly 
0046      * based on the field names.</p>
0047      *
0048      * @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>
0049      * 
0050      * @javascript <b>Opaque</b> types can be resolved but no class objects for them can be created 
0051      * in the target codes. Re-compilers must exit with error on operations accessing that kind 
0052      * of class objects.
0053      * Re-compilers must resolve an <b>opaque</b> instance field declared by this class in 
0054      * {@link js.Var.Member} or its subclasses to the JavaScript identifier: 
0055      * <pre>q.m</pre>
0056      * where <tt>m</tt> is the identifier of the field name and <tt>q</tt> is the identifier 
0057      * resolved from the instance of the enclosing member. Re-compilers must resolve an 
0058      * <b>opaque</b> static field declared by this class in <b>opaque</b> types other than 
0059      * {@link js.Var.Member} and its subclasses to the JavaScript identifier: 
0060      * <pre>m</pre>
0061      * where <tt>m</tt> is the identifier of the field name. And re-compilers must report 
0062      * error on the access to <b>opaque</b> fields declared by this class under any other 
0063      * circumstances.
0064      */
0065     public static class Member extends JsGlobal.Date.Prototype.Member
0066     {
0067         /**
0068          * <p>Internally constructs a member based on a qualifying member.</p>
0069          * <p>This constructor is <b>internal</b> and only called inside of <b>opaque</b> 
0070          * or <b>internal</b> classes or class members.</p>
0071          * <p>Note that, this constructor is <b>internal</b> but its declaring class is 
0072          * <b>opaque</b>. This constructor is used to define <b>opaque</b> instance fields 
0073          * declared in the declaring class of this constructor itself or its subclasses. 
0074          * Under this circumstance, the field names must be exactly same as the member 
0075          * names, as the <b>opaque</b> instance fields of the <b>opaque</b> type 
0076          * {@link js.Var.Member} or its subclasses are resolved by re-compilers directly 
0077          * to their names appending to the name resolved from the specified qualifying 
0078          * member with a dot in between.</p>
0079          * @param q A qualifying member
0080          * @param mid The ID of the member to construct
0081          * @since 1.0
0082          * @javascript Re-compilers must report error on the invocation to an <b>internal</b> constructor. 
0083          */
0084         public Member(JsObject.Member q, Mid mid) {
0085             super(q, mid);
0086         }
0087         /**
0088          * <p>Internally constructs a member without a qualifying member.</p>
0089          * <p>This constructor is <b>internal</b> and only called inside of <b>opaque</b> 
0090          * or <b>internal</b> classes or class members.</p>
0091          * <p>Note that, this constructor is <b>internal</b> but its declaring class is 
0092          * <b>opaque</b>. This constructor is used to define <b>opaque</b> static fields, 
0093          * declared in <b>opaque</b> types other than the declaring class of this constructor 
0094          * itself and its subclasses. Under this circumstance, the field names must be 
0095          * exactly same as the member names, as the <b>opaque</b> static fields of <b>opaque</b> 
0096          * types are generally resolved by re-compilers directly to identifiers of their names.</p>
0097          * @param mid The ID of the member to construct
0098          * @since 1.0
0099          * @javascript Re-compilers must report error on the invocation to an <b>internal</b> constructor. 
0100          */
0101         public Member(Mid mid) {
0102             super(mid);
0103         }
0104         /**
0105          * <p>Evaluates the property, represented by the current member instance, of the 
0106          * argument object.</p>
0107          * @param o The argument object
0108          * @return The value of the current member based on the object argument.
0109          * @since 1.0
0110          * @javascript Re-compilers must convert the instance invocation of this method into 
0111          * the JavaScript expression: 
0112          * <pre>o.m</pre>
0113          * where <tt>m</tt> is the identifier name resolved from the current member 
0114          * instance of the invocation.
0115          */
0116         @Override
0117         public JsDate with(ObjectLike o) {
0118             return new JsDate((JsObject)var(o).var(mid()));
0119         }
0120 
0121         /**
0122          * <p>An <b>opaque</b> instance field defining a sub-member that is named by the 
0123          * name of this field, qualified by the current member instance of the field, and 
0124          * to access the property of the name on an object.</p>
0125          * <p>The <tt>constructor</tt> property of an object is a reference to the function 
0126          * that was the constructor for that object.</p>
0127          * <p>A common use of the <tt>constructor</tt> property is to determine the type of unknown 
0128          * objects. Given an unknown value, you can use the {@link js.Js#typeof(Object)} operation 
0129          * to determine whether it is a primitive value or an object. If it is an object, you can 
0130          * use the <tt>constructor</tt> property to determine what type of object it is.</p>
0131          * <p>Note, however, that while this technique works for the objects built into core 
0132          * JavaScript, it is not guaranteed to work with host objects such as the <tt>window</tt> 
0133          * object of client-side JavaScript. The default implementation of the <tt>toString()</tt> 
0134          * method provides another way to determine the type of an unknown object.</p>
0135          * @since 1.0
0136          * @javascript Re-compilers must resolve the member of this instance field to the 
0137          * identifier of the field name appending to the identifier resolved from its 
0138          * qualifying member with a dot in between.
0139          */
0140         public final JsFunction.Member<JsDate> constructor = new JsFunction.Member<JsDate>(this, Members.constructor, Generic.get(JsDate.class));
0141     }
0142 
0143     /**
0144      * <p>Internally constructs a date object.</p>
0145      * <p>This constructor is <b>internal</b> and only called inside of <b>opaque</b> or 
0146      * <b>internal</b> classes or class members.</p>
0147      * <p>Note that, The Java class <tt>java.lang.String</tt> and Java basic classes that 
0148      * wrap primitive data types are also "primitive" to JS.</p>
0149      * @since 1.0
0150      * @javascript Re-compilers must report error on the invocation to an <b>internal</b> constructor. 
0151      */
0152     protected JsDate(Object var) {
0153         super((JsObject)var);
0154     }
0155     /**
0156      * <p>Casts an <b>opaque</b> object to the current <b>opaque</b> type by wrapping it 
0157      * with the wrapping constructor.</p>
0158      * @param var The argument of an <b>opaque</b> object.
0159      * @since 1.0
0160      * @javascript Re-compilers must ignore the construction operation of this constructor, 
0161      * that is, replacing it with its only argument.
0162      */
0163     public JsDate(JsObject var) {
0164         super(var(var, (JsDate)null));
0165     }
0166     /**
0167      * <p>Constructs a date object set to the current date and time.</p>
0168      * @since 1.0
0169      * @see Js#date()
0170      * @see #JsDate(js.core.JsObject)
0171      * @see #JsDate(NumberLike)
0172      * @see #JsDate(String)
0173      * @see #JsDate(StringLike)
0174      * @see #JsDate(Object, Object)
0175      * @see #JsDate(Object, Object, Object)
0176      * @see #JsDate(Object, Object, Object, Object)
0177      * @see #JsDate(Object, Object, Object, Object, Object)
0178      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0179      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0180      * @see js.core.JsGlobal.Date#create()
0181      * @see js.core.JsGlobal.Date#create(Vars)
0182      * @javascript Re-compilers must replace the construction operation of this constructor 
0183      * with the JavaScript expression:
0184      * <pre>new Date(milliseconds)</pre>
0185      */
0186     public JsDate() {
0187         this(JsGlobal.Date.with().create());
0188     }
0189     /**
0190      * <p>Constructs a date object taking <tt>milliseconds</tt> as the internal numeric 
0191      * representation as returned by {@link #getTime()}.</p>
0192      * @param milliseconds The numeric representation of the date in milliseconds.
0193      * @since 1.0
0194      * @see Js#date(Number)
0195      * @see #JsDate(js.core.JsObject)
0196      * @see #JsDate(NumberLike)
0197      * @see #JsDate(String)
0198      * @see #JsDate(StringLike)
0199      * @see #JsDate(Object, Object)
0200      * @see #JsDate(Object, Object, Object)
0201      * @see #JsDate(Object, Object, Object, Object)
0202      * @see #JsDate(Object, Object, Object, Object, Object)
0203      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0204      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0205      * @see js.core.JsGlobal.Date#create()
0206      * @see js.core.JsGlobal.Date#create(Vars)
0207      * @see js.core.JsGlobal.Date#create(Number)
0208      * @see js.core.JsGlobal.Date#create(NumberLike)
0209      * @see js.core.JsGlobal.Date#create(Object)
0210      * @javascript Re-compilers must replace the construction operation of this constructor 
0211      * with the JavaScript expression:
0212      * <pre>new Date(milliseconds)</pre>
0213      */
0214     public JsDate(Number milliseconds) {
0215         this(JsGlobal.Date.with().create(milliseconds));
0216     }
0217     /**
0218      * <p>Constructs a date object taking <tt>milliseconds</tt> as the internal numeric 
0219      * representation as returned by {@link #getTime()}.</p>
0220      * @param milliseconds The numeric representation of the date in milliseconds.
0221      * @since 1.0
0222      * @see Js#date(Number)
0223      * @see #JsDate(js.core.JsObject)
0224      * @see #JsDate(Number)
0225      * @see #JsDate(String)
0226      * @see #JsDate(StringLike)
0227      * @see #JsDate(Object, Object)
0228      * @see #JsDate(Object, Object, Object)
0229      * @see #JsDate(Object, Object, Object, Object)
0230      * @see #JsDate(Object, Object, Object, Object, Object)
0231      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0232      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0233      * @see js.core.JsGlobal.Date#create(Vars)
0234      * @see js.core.JsGlobal.Date#create(Number)
0235      * @see js.core.JsGlobal.Date#create(NumberLike)
0236      * @see js.core.JsGlobal.Date#create(Object)
0237      * @javascript Re-compilers must replace the construction operation of this constructor 
0238      * with the JavaScript expression:
0239      * <pre>new Date(milliseconds)</pre>
0240      */
0241     public JsDate(NumberLike<?> milliseconds) {
0242         this(JsGlobal.Date.with().create(milliseconds));
0243     }
0244     /**
0245      * <p>Constructs a date object taking <tt>datestring</tt> as the string representation, 
0246      * in the format accepted by the {@link js.core.JsGlobal.Date#parse(Object)} method.</p>
0247      * @param datestring The string representation of the date to construct.
0248      * @since 1.0
0249      * @see Js#date(String)
0250      * @see #JsDate(js.core.JsObject)
0251      * @see #JsDate(Number)
0252      * @see #JsDate(NumberLike)
0253      * @see #JsDate(StringLike)
0254      * @see #JsDate(Object, Object)
0255      * @see #JsDate(Object, Object, Object)
0256      * @see #JsDate(Object, Object, Object, Object)
0257      * @see #JsDate(Object, Object, Object, Object, Object)
0258      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0259      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0260      * @see js.core.JsGlobal.Date#create(Vars)
0261      * @see js.core.JsGlobal.Date#create(Object)
0262      * @javascript Re-compilers must replace the construction operation of this constructor 
0263      * with the JavaScript expression:
0264      * <pre>new Date(datestring)</pre>
0265      */
0266     public JsDate(String datestring) {
0267         this(JsGlobal.Date.with().create(datestring));
0268     }
0269     /**
0270      * <p>Constructs a date object taking <tt>datestring</tt> as the string representation, 
0271      * in the format accepted by the {@link js.core.JsGlobal.Date#parse(Object)} method.</p>
0272      * @param datestring The string representation of the date to construct.
0273      * @since 1.0
0274      * @see Js#date(String)
0275      * @see #JsDate(js.core.JsObject)
0276      * @see #JsDate(Number)
0277      * @see #JsDate(NumberLike)
0278      * @see #JsDate(String)
0279      * @see #JsDate(Object, Object)
0280      * @see #JsDate(Object, Object, Object)
0281      * @see #JsDate(Object, Object, Object, Object)
0282      * @see #JsDate(Object, Object, Object, Object, Object)
0283      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0284      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0285      * @see js.core.JsGlobal.Date#create(Vars)
0286      * @see js.core.JsGlobal.Date#create(Object)
0287      * @javascript Re-compilers must replace the construction operation of this constructor 
0288      * with the JavaScript expression:
0289      * <pre>new Date(datestring)</pre>
0290      */
0291     public JsDate(StringLike datestring) {
0292         this(JsGlobal.Date.with().create(datestring));
0293     }
0294     /**
0295      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0296      * individual fields of the date and time. All but the first two arguments, the year 
0297      * and month fields, are optional.</p>
0298      * <p>Note that these date and time fields are specified using local time, not 
0299      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0300      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object)}
0301      * method for an alternative.</p>
0302      * @param yr The year, in four-digit format. For compatibility with early implementations 
0303      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0304      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0305      * @since 1.0
0306      * @see #JsDate(js.core.JsObject)
0307      * @see #JsDate(Number)
0308      * @see #JsDate(NumberLike)
0309      * @see #JsDate(String)
0310      * @see #JsDate(StringLike)
0311      * @see #JsDate(Object, Object, Object)
0312      * @see #JsDate(Object, Object, Object, Object)
0313      * @see #JsDate(Object, Object, Object, Object, Object)
0314      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0315      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0316      * @see js.core.JsGlobal.Date#create(Object, Object)
0317      * @javascript Re-compilers must replace the construction operation of this constructor 
0318      * with the JavaScript expression:
0319      * <pre>new Date(yr, mo)</pre>
0320      */
0321     public JsDate(Object yr, Object mo) {
0322         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo)));
0323     }
0324     /**
0325      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0326      * individual fields of the date and time. All but the first two arguments, the year 
0327      * and month fields, are optional.</p>
0328      * <p>Note that these date and time fields are specified using local time, not 
0329      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0330      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object, Object)}
0331      * method for an alternative.</p>
0332      * @param yr The year, in four-digit format. For compatibility with early implementations 
0333      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0334      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0335      * @param day The day of the month, specified as an integer from 1 to 31. Note that 
0336      * this argument uses 1 as its lowest value, while other arguments use 0 as their 
0337      * lowest value. Optional.
0338      * @since 1.0
0339      * @see #JsDate(js.core.JsObject)
0340      * @see #JsDate(Number)
0341      * @see #JsDate(NumberLike)
0342      * @see #JsDate(String)
0343      * @see #JsDate(StringLike)
0344      * @see #JsDate(Object, Object)
0345      * @see #JsDate(Object, Object, Object, Object)
0346      * @see #JsDate(Object, Object, Object, Object, Object)
0347      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0348      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0349      * @see js.core.JsGlobal.Date#create(Object, Object, Object)
0350      * @javascript Re-compilers must replace the construction operation of this constructor 
0351      * with the JavaScript expression:
0352      * <pre>new Date(yr, mo, day)</pre>
0353      */
0354     public JsDate(Object yr, Object mo, Object day) {
0355         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo).add(day)));
0356     }
0357     /**
0358      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0359      * individual fields of the date and time. All but the first two arguments, the year 
0360      * and month fields, are optional.</p>
0361      * <p>Note that these date and time fields are specified using local time, not 
0362      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0363      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object, Object, Object)}
0364      * method for an alternative.</p>
0365      * @param yr The year, in four-digit format. For compatibility with early implementations 
0366      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0367      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0368      * @param day The day of the month, specified as an integer from 1 to 31. Note that 
0369      * this argument uses 1 as its lowest value, while other arguments use 0 as their 
0370      * lowest value. Optional.
0371      * @param hr The hour, specified as an integer from 0 (midnight) to 23 (11 p.m.). 
0372      * Optional.
0373      * @see #JsDate(js.core.JsObject)
0374      * @see #JsDate(Number)
0375      * @see #JsDate(NumberLike)
0376      * @see #JsDate(String)
0377      * @see #JsDate(StringLike)
0378      * @see #JsDate(Object, Object)
0379      * @see #JsDate(Object, Object, Object)
0380      * @see #JsDate(Object, Object, Object, Object, Object)
0381      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0382      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0383      * @see js.core.JsGlobal.Date#create(Object, Object, Object, Object)
0384      * @javascript Re-compilers must replace the construction operation of this constructor 
0385      * with the JavaScript expression:
0386      * <pre>new Date(yr, mo, day, hr)</pre>
0387      */
0388     public JsDate(Object yr, Object mo, Object day, Object hr) {
0389         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo).add(day).add(hr)));
0390     }
0391     /**
0392      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0393      * individual fields of the date and time. All but the first two arguments, the year 
0394      * and month fields, are optional.</p>
0395      * <p>Note that these date and time fields are specified using local time, not 
0396      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0397      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object)}
0398      * method for an alternative.</p>
0399      * @param yr The year, in four-digit format. For compatibility with early implementations 
0400      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0401      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0402      * @param day The day of the month, specified as an integer from 1 to 31. Note that 
0403      * this argument uses 1 as its lowest value, while other arguments use 0 as their 
0404      * lowest value. Optional.
0405      * @param hr The hour, specified as an integer from 0 (midnight) to 23 (11 p.m.). 
0406      * Optional.
0407      * @param min The minutes in the hour, specified as an integer from 0 to 59. Optional.
0408      * @since 1.0
0409      * @see #JsDate(js.core.JsObject)
0410      * @see #JsDate(Number)
0411      * @see #JsDate(NumberLike)
0412      * @see #JsDate(String)
0413      * @see #JsDate(StringLike)
0414      * @see #JsDate(Object, Object)
0415      * @see #JsDate(Object, Object, Object)
0416      * @see #JsDate(Object, Object, Object, Object)
0417      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0418      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0419      * @see js.core.JsGlobal.Date#create(Object, Object, Object, Object, Object)
0420      * @javascript Re-compilers must replace the construction operation of this constructor 
0421      * with the JavaScript expression:
0422      * <pre>new Date(yr, mo, day, hr, min)</pre>
0423      */
0424     public JsDate(Object yr, Object mo, Object day, Object hr, Object min) {
0425         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo).add(day).add(hr).add(min)));
0426     }
0427     /**
0428      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0429      * individual fields of the date and time. All but the first two arguments, the year 
0430      * and month fields, are optional.</p>
0431      * <p>Note that these date and time fields are specified using local time, not 
0432      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0433      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object, Object)}
0434      * method for an alternative.</p>
0435      * @param yr The year, in four-digit format. For compatibility with early implementations 
0436      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0437      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0438      * @param day The day of the month, specified as an integer from 1 to 31. Note that 
0439      * this argument uses 1 as its lowest value, while other arguments use 0 as their 
0440      * lowest value. Optional.
0441      * @param hr The hour, specified as an integer from 0 (midnight) to 23 (11 p.m.). 
0442      * Optional.
0443      * @param min The minutes in the hour, specified as an integer from 0 to 59. Optional.
0444      * @param sec The seconds in the minute, specified as an integer from 0 to 59. Optional.
0445      * @since 1.0
0446      * @see #JsDate(js.core.JsObject)
0447      * @see #JsDate(Number)
0448      * @see #JsDate(NumberLike)
0449      * @see #JsDate(String)
0450      * @see #JsDate(StringLike)
0451      * @see #JsDate(Object, Object)
0452      * @see #JsDate(Object, Object, Object)
0453      * @see #JsDate(Object, Object, Object, Object)
0454      * @see #JsDate(Object, Object, Object, Object, Object)
0455      * @see #JsDate(Object, Object, Object, Object, Object, Object, Object)
0456      * @see js.core.JsGlobal.Date#create(Object, Object, Object, Object, Object, Object)
0457      * @javascript Re-compilers must replace the construction operation of this constructor 
0458      * with the JavaScript expression:
0459      * <pre>new Date(yr, mo, day, hr, min, sec)</pre>
0460      */
0461     public JsDate(Object yr, Object mo, Object day, Object hr, Object min, Object sec) {
0462         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo).add(day).add(hr).add(min).add(sec)));
0463     }
0464     /**
0465      * <p>Constructs a date object with two to seven numeric arguments that specify the 
0466      * individual fields of the date and time. All but the first two arguments, the year 
0467      * and month fields, are optional.</p>
0468      * <p>Note that these date and time fields are specified using local time, not 
0469      * Coordinated Universal Time (UTC) (which is similar to Greenwich Mean Time [GMT]). 
0470      * See the static {@link js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object, Object, Object)}
0471      * method for an alternative.</p>
0472      * @param yr The year, in four-digit format. For compatibility with early implementations 
0473      * of JavaScript, if this argument is between 0 and 99, 1900 is added to it.
0474      * @param mo The month, specified as an integer from 0 (January) to 11 (December).
0475      * @param day The day of the month, specified as an integer from 1 to 31. Note that 
0476      * this argument uses 1 as its lowest value, while other arguments use 0 as their 
0477      * lowest value. Optional.
0478      * @param hr The hour, specified as an integer from 0 (midnight) to 23 (11 p.m.). 
0479      * Optional.
0480      * @param min The minutes in the hour, specified as an integer from 0 to 59. Optional.
0481      * @param sec The seconds in the minute, specified as an integer from 0 to 59. Optional.
0482      * @param ms The milliseconds in the second, specified as an integer from 0 to 999. 
0483      * Optional.
0484      * @since 1.0
0485      * @see #JsDate(js.core.JsObject)
0486      * @see #JsDate(Number)
0487      * @see #JsDate(NumberLike)
0488      * @see #JsDate(String)
0489      * @see #JsDate(StringLike)
0490      * @see #JsDate(Object, Object)
0491      * @see #JsDate(Object, Object, Object)
0492      * @see #JsDate(Object, Object, Object, Object)
0493      * @see #JsDate(Object, Object, Object, Object, Object)
0494      * @see #JsDate(Object, Object, Object, Object, Object, Object)
0495      * @see js.core.JsGlobal.Date#create(Object, Object, Object, Object, Object, Object, Object)
0496      * @javascript Re-compilers must replace the construction operation of this constructor 
0497      * with the JavaScript expression:
0498      * <pre>new Date(yr, mo, day, hr, min, sec, ms)</pre>
0499      */
0500     public JsDate(Object yr, Object mo, Object day, Object hr, Object min, Object sec, Object ms) {
0501         this(JsGlobal.Date.with().create(new Vars<Object>().add(yr).add(mo).add(day).add(hr).add(min).add(sec).add(ms)));
0502     }
0503 
0504     /**
0505      * <p>Simply returns the current date instance.</p>
0506      * <p>This method is useful for JS Simulation to implement opaque types.</p>
0507      * @return The current boolean instance.
0508      * @since 1.0
0509      * @javascript Re-compilers must ignore the instance invocation of this method, that is, 
0510      * replacing it with its current instance.
0511      */
0512     @Override
0513     public JsDate var() {
0514         return (JsDate)super.var();
0515     }
0516     /**
0517      * <p>Assigns the value of another date instance to the current date object.</p>
0518      * @param var The argument date instance.
0519      * @return The new instance.
0520      * @since 1.0
0521      * @javascript Re-compilers must convert the instance invocation of this method into 
0522      * the JavaScript expression: 
0523      * <pre>o = var</pre>
0524      * where <tt>o</tt> is the current instance of the invocation of this method.
0525      */
0526     @Override
0527     public final <S extends JsObject> S var(S var) {
0528         var(var, (JsDate)null);
0529         return var;
0530     }
0531 
0532     /**
0533      * <p>An <b>opaque</b> static field defining a member that is named by the field name 
0534      * without a qualifying member and to access the property of the name on an object.</p>
0535      * <p>The <tt>constructor</tt> property of an object is a reference to the function 
0536      * that was the constructor for that object.</p>
0537      * <p>A common use of the <tt>constructor</tt> property is to determine the type of unknown 
0538      * objects. Given an unknown value, you can use the {@link js.Js#typeof(Object)} operation 
0539      * to determine whether it is a primitive value or an object. If it is an object, you can 
0540      * use the <tt>constructor</tt> property to determine what type of object it is.</p>
0541      * <p>Note, however, that while this technique works for the objects built into core 
0542      * JavaScript, it is not guaranteed to work with host objects such as the <tt>window</tt> 
0543      * object of client-side JavaScript. The default implementation of the <tt>toString()</tt> 
0544      * method provides another way to determine the type of an unknown object.</p>
0545      * @since 1.0
0546      * @javascript Re-compilers must resolve the member of this static field to the 
0547      * identifier of the field name.
0548      */
0549     public static final JsFunction.Member<JsDate> constructor = new JsFunction.Member<JsDate>(Members.constructor, Generic.get(JsDate.class));
0550 
0551     /**
0552      * <p>Returns the internal, millisecond representation of the current date instance.</p>
0553      * <p>It converts the current date instance to a single integer. This is useful when 
0554      * you want to compare two date instances or to determine the time elapsed between two 
0555      * dates. Note that the millisecond representation of a date is independent of the 
0556      * time zone, so there is no <tt>getUTCTime()</tt> method in addition to this one. 
0557      * Don't confuse this method with the {@link #getDay()} and {@link #getDate()} methods, 
0558      * which return the day of the week and the day of the month, respectively</p>
0559      * <p>{@link js.core.JsGlobal.Date#parse(Object)} and {@link js.core.JsGlobal.Date#UTC(Object, Object)} 
0560      * allow you to convert a date and time specification to a millisecond representation without 
0561      * going through the overhead of first creating a date object.</p>
0562      * @return The millisecond representation of the current date instance, that is, the 
0563      * number of milliseconds between midnight (GMT) on 1/1/1970 and the date and time 
0564      * specified by the date.
0565      * @see #setTime(Object)
0566      * @see js.core.JsGlobal.Date#parse(Object)
0567      * @see js.core.JsGlobal.Date#UTC(Object, Object)
0568      * @see js.core.JsGlobal.Date#UTC(Object, Object, Object)
0569      * @see js.core.JsGlobal.Date#UTC(Object, Object, Object, Object)
0570      * @see js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object)
0571      * @see js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object, Object)
0572      * @see js.core.JsGlobal.Date#UTC(Object, Object, Object, Object, Object, Object, Object)
0573      * @see jsx.core.DateLikes#getTime(DateLike)
0574      * @since 1.0
0575      * @javascript Re-compilers must convert the instance invocation of this method directly 
0576      * into a JavaScript invocation on its current date instance without changing the 
0577      * method name, but expanding variable arguments, if any, into comma-separated values. 
0578      */
0579     public final Number getTime() {
0580         return call(getTime);
0581     }
0582     /**
0583      * <p>Returns the year of the current date instance in full four-digit form, in local 
0584      * time.</p>
0585      * @return The year that results when the current date instance is expressed in local 
0586      * time. The return value is a full four-digit year, including the century, not a 
0587      * two-digit abbreviation..
0588      * @see #getUTCFullYear()
0589      * @see jsx.core.DateLikes#getFullYear(DateLike)
0590      * @since 1.0
0591      * @javascript Re-compilers must convert the instance invocation of this method directly 
0592      * into a JavaScript invocation on its current date instance without changing the 
0593      * method name, but expanding variable arguments, if any, into comma-separated values. 
0594      */
0595     public final Number getFullYear() {
0596         return call(getFullYear);
0597     }
0598     /**
0599      * <p>Returns the year of the current date instance in full four-digit form, in 
0600      * universal time.</p>
0601      * @return The year that results when the current date instance is expressed in 
0602      * universal time. The return value is a full four-digit year, not a two-digit 
0603      * abbreviation.
0604      * @see #getFullYear()
0605      * @see jsx.core.DateLikes#getUTCFullYear(DateLike)
0606      * @since 1.0
0607      * @javascript Re-compilers must convert the instance invocation of this method directly 
0608      * into a JavaScript invocation on its current date instance without changing the 
0609      * method name, but expanding variable arguments, if any, into comma-separated values. 
0610      */
0611     public final Number getUTCFullYear() {
0612         return call(getUTCFullYear);
0613     }
0614     /**
0615      * <p>Returns the month field of the current date instance, in local time.</p>
0616      * @return The month of the year that results when the current date instance is 
0617      * expressed in local time. The return value is an integer between 0 (January) 
0618      * and 11 (December). Note that the date represents the first day of the month as 1 
0619      * but represents the first month of the year as 0.
0620      * @see #getUTCMonth()
0621      * @see jsx.core.DateLikes#getMonth(DateLike)
0622      * @since 1.0
0623      * @javascript Re-compilers must convert the instance invocation of this method directly 
0624      * into a JavaScript invocation on its current date instance without changing the 
0625      * method name, but expanding variable arguments, if any, into comma-separated values. 
0626      */
0627     public final Number getMonth() {
0628         return call(getMonth);
0629     }
0630     /**
0631      * <p>Returns the month field of the current date instance, in universal time.</p>
0632      * @return The month of the year that results when the current date instance is 
0633      * expressed in universal time. The return value is an integer between 0 (January) 
0634      * and 11 (December). Note that the date represents the first day of the month as 1 
0635      * but represents the first month of the year as 0.
0636      * @see #getMonth()
0637      * @see jsx.core.DateLikes#getUTCMonth(DateLike)
0638      * @since 1.0
0639      * @javascript Re-compilers must convert the instance invocation of this method directly 
0640      * into a JavaScript invocation on its current date instance without changing the 
0641      * method name, but expanding variable arguments, if any, into comma-separated values. 
0642      */
0643     public final Number getUTCMonth() {
0644         return call(getUTCMonth);
0645     }
0646     /**
0647      * <p>Returns the day of the month of the current date instance, in local time.</p>
0648      * @return The day of the month of the current date instance, using local time. 
0649      * Return values are between 1 and 31.
0650      * @see #getUTCDate()
0651      * @see jsx.core.DateLikes#getDate(DateLike)
0652      * @since 1.0
0653      * @javascript Re-compilers must convert the instance invocation of this method directly 
0654      * into a JavaScript invocation on its current date instance without changing the 
0655      * method name, but expanding variable arguments, if any, into comma-separated values. 
0656      */
0657     public final Number getDate() {
0658         return call(getDate);
0659     }
0660     /**
0661      * <p>Returns the day of the month of the current date instance, in universal time.</p>
0662      * @return The day of the month (a value between 1 and 31) that results when the 
0663      * current date instance is expressed in universal time.
0664      * @see jsx.core.DateLikes#getUTCDate(DateLike)
0665      * @since 1.0
0666      * @javascript Re-compilers must convert the instance invocation of this method directly 
0667      * into a JavaScript invocation on its current date instance without changing the 
0668      * method name, but expanding variable arguments, if any, into comma-separated values. 
0669      */
0670     public final Number getUTCDate() {
0671         return call(getUTCDate);
0672     }
0673     /**
0674      * <p>Returns the day of the week of the current date instance, in local time.</p>
0675      * @return The day of the week of the current date instance, using local time. Return values 
0676      * are between 0 (Sunday) and 6 (Saturday).
0677      * @see #getUTCDay()
0678      * @see jsx.core.DateLikes#getDay(DateLike)
0679      * @since 1.0
0680      * @javascript Re-compilers must convert the instance invocation of this method directly 
0681      * into a JavaScript invocation on its current date instance without changing the 
0682      * method name, but expanding variable arguments, if any, into comma-separated values. 
0683      */
0684     public final Number getDay() {
0685         return call(getDay);
0686     }
0687     /**
0688      * <p>Returns the day of the week of current date instance, in universal time.</p>
0689      * @return The day of the week that results when the current date instance is expressed 
0690      * in universal time. Return values are between 0 (Sunday) and 6 (Saturday).
0691      * @see #getDay()
0692      * @see jsx.core.DateLikes#getUTCDay(DateLike)
0693      * @since 1.0
0694      * @javascript Re-compilers must convert the instance invocation of this method directly 
0695      * into a JavaScript invocation on its current date instance without changing the 
0696      * method name, but expanding variable arguments, if any, into comma-separated values. 
0697      */
0698     public final Number getUTCDay() {
0699         return call(getUTCDay);
0700     }
0701     /**
0702      * <p>Returns the hours field of the current date instance, in local time.</p>
0703      * @return The hours field, expressed in local time, of the current date instance. 
0704      * Return values are between 0 (midnight) and 23 (11 p.m.).
0705      * @see #getUTCHours()
0706      * @see jsx.core.DateLikes#getHours(DateLike)
0707      * @since 1.0
0708      * @javascript Re-compilers must convert the instance invocation of this method directly 
0709      * into a JavaScript invocation on its current date instance without changing the 
0710      * method name, but expanding variable arguments, if any, into comma-separated values. 
0711      */
0712     public final Number getHours() {
0713         return call(getHours);
0714     }
0715     /**
0716      * <p>Returns the hours field of the current date instance, in universal time.</p>
0717      * @return The hours field, expressed in universal time, of the current date instance. 
0718      * The return value is an integer between 0 (midnight) and 23 (11 p.m.).
0719      * @see #getHours()
0720      * @see jsx.core.DateLikes#getUTCHours(DateLike)
0721      * @since 1.0
0722      * @javascript Re-compilers must convert the instance invocation of this method directly 
0723      * into a JavaScript invocation on its current date instance without changing the 
0724      * method name, but expanding variable arguments, if any, into comma-separated values. 
0725      */
0726     public final Number getUTCHours() {
0727         return call(getUTCHours);
0728     }
0729     /**
0730      * <p>Returns the minutes field of a Date object, in local or universal time.</p>
0731      * @return The minutes field, expressed in local time, of the current date instance. 
0732      * Return values are between 0 and 59.
0733      * @see #getUTCMinutes()
0734      * @see jsx.core.DateLikes#getMinutes(DateLike)
0735      * @since 1.0
0736      * @javascript Re-compilers must convert the instance invocation of this method directly 
0737      * into a JavaScript invocation on its current date instance without changing the 
0738      * method name, but expanding variable arguments, if any, into comma-separated values. 
0739      */
0740     public final Number getMinutes() {
0741         return call(getMinutes);
0742     }
0743     /**
0744      * <p>Returns the minutes field of the current date instance, in universal time.</p>
0745      * @return The minutes field, expressed in universal time, of the current date instance. 
0746      * The return value is an integer between 0 and 59.
0747      * @see #getMinutes()
0748      * @see jsx.core.DateLikes#getUTCMinutes(DateLike)
0749      * @since 1.0
0750      * @javascript Re-compilers must convert the instance invocation of this method directly 
0751      * into a JavaScript invocation on its current date instance without changing the 
0752      * method name, but expanding variable arguments, if any, into comma-separated values. 
0753      */
0754     public final Number getUTCMinutes() {
0755         return call(getUTCMinutes);
0756     }
0757     /**
0758      * <p>Returns the seconds field of the current date instance, in local time.</p>
0759      * @return The seconds field, expressed in local time, of the current date instance. 
0760      * Return values are between 0 and 59.
0761      * @see #getUTCSeconds()
0762      * @see jsx.core.DateLikes#getSeconds(DateLike)
0763      * @since 1.0
0764      * @javascript Re-compilers must convert the instance invocation of this method directly 
0765      * into a JavaScript invocation on its current date instance without changing the 
0766      * method name, but expanding variable arguments, if any, into comma-separated values. 
0767      */
0768     public final Number getSeconds() {
0769         return call(getSeconds);
0770     }
0771     /**
0772      * <p>Returns the seconds field of the current date instance, in universal time.</p>
0773      * @return The seconds field, expressed in universal time, of the current date instance. 
0774      * The return value is an integer between 0 and 59.
0775      * @see #getSeconds()
0776      * @see jsx.core.DateLikes#getUTCSeconds(DateLike)
0777      * @since 1.0
0778      * @javascript Re-compilers must convert the instance invocation of this method directly 
0779      * into a JavaScript invocation on its current date instance without changing the 
0780      * method name, but expanding variable arguments, if any, into comma-separated values. 
0781      */
0782     public final Number getUTCSeconds() {
0783         return call(getUTCSeconds);
0784     }
0785     /**
0786      * <p>Returns the milliseconds field of the current date instance, in local time.</p>
0787      * @return The milliseconds field, expressed in local time, of the current date instance.
0788      * @see #getUTCMilliseconds()
0789      * @see jsx.core.DateLikes#getMilliseconds(DateLike)
0790      * @since 1.0
0791      * @javascript Re-compilers must convert the instance invocation of this method directly 
0792      * into a JavaScript invocation on its current date instance without changing the 
0793      * method name, but expanding variable arguments, if any, into comma-separated values. 
0794      */
0795     public final Number getMilliseconds() {
0796         return call(getMilliseconds);
0797     }
0798     /**
0799      * <p>Returns the milliseconds field of current date instance, in universal time.</p>
0800      * @return The milliseconds field, expressed in universal time, of the current date instance.
0801      * @see #getMilliseconds()
0802      * @see jsx.core.DateLikes#getUTCMilliseconds(DateLike)
0803      * @since 1.0
0804      * @javascript Re-compilers must convert the instance invocation of this method directly 
0805      * into a JavaScript invocation on its current date instance without changing the 
0806      * method name, but expanding variable arguments, if any, into comma-separated values. 
0807      */
0808     public final Number getUTCMilliseconds() {
0809         return call(getUTCMilliseconds);
0810     }
0811     /**
0812      * <p>Returns the difference, in minutes, between the local and UTC representations of 
0813      * the current date instance. Note that the value returned depends on whether daylight 
0814      * saving time is or would be in effect at the specific date.</p>
0815      * <p>The return value is measured in minutes, rather than hours, because some 
0816      * countries have time zones that are not at even one-hour intervals.</p>
0817      * @return The difference, in minutes, between GMT and local time.
0818      * @see jsx.core.DateLikes#getTimezoneOffset(DateLike)
0819      * @since 1.0
0820      * @javascript Re-compilers must convert the instance invocation of this method directly 
0821      * into a JavaScript invocation on its current date instance without changing the 
0822      * method name, but expanding variable arguments, if any, into comma-separated values. 
0823      */
0824     public final Number getTimezoneOffset() {
0825         return call(getTimezoneOffset);
0826     }
0827     /**
0828      * <p>Sets the fields of the current date instance using the millisecond format.</p>
0829      * @param time The number of milliseconds between the desired date and time and 
0830      * midnight GMT on January 1, 1970. A millisecond value of this type may also be 
0831      * passed to the {@link Js#date(Number)}, {@link js.core.JsDate#JsDate(Number)}, 
0832      * {@link js.core.JsDate#JsDate(NumberLike)}, {@link js.core.JsDate#JsDate(String)}, 
0833      * {@link js.core.JsDate#JsDate(StringLike)}, {@link js.core.JsGlobal.Date#create(Number)} 
0834      * or {@link js.core.JsGlobal.Date#create(Number)} and may be obtained by calling the 
0835      * {@link js.core.JsGlobal.Date#UTC(Object, Object)} and {@link js.core.JsGlobal.Date#parse(Object)} 
0836      * methods. Representing a date in this millisecond format makes it independent of 
0837      * time zone.
0838      * @return The <tt>time</tt> argument. Prior to ECMAScript standardization, 
0839      * this method returns nothing.
0840      * @see jsx.core.DateLikes#setTime(DateLike, Object)
0841      * @since 1.0
0842      * @javascript Re-compilers must convert the instance invocation of this method directly 
0843      * into a JavaScript invocation on its current date instance without changing the 
0844      * method name, but expanding variable arguments, if any, into comma-separated values. 
0845      */
0846     public final Number setTime(Object time) {
0847         return call(setTime, time);
0848     }
0849     /**
0850      * <p>Sets the milliseconds field of a date, using local time.</p>
0851      * @param ms The milliseconds field, expressed in local time, to be set in the current 
0852      * date instance. This argument should be an integer between 0 and 999.
0853      * @return The millisecond representation of the adjusted date.
0854      * @see #setUTCMilliseconds(Object)
0855      * @see jsx.core.DateLikes#setMilliseconds(DateLike, Object)
0856      * @since 1.0
0857      * @javascript Re-compilers must convert the instance invocation of this method directly 
0858      * into a JavaScript invocation on its current date instance without changing the 
0859      * method name, but expanding variable arguments, if any, into comma-separated values. 
0860      */
0861     public final Number setMilliseconds(Object ms) {
0862         return call(setMilliseconds, ms);
0863     }
0864     /**
0865      * <p>Sets the milliseconds field of the current date instance, using universal time.</p>
0866      * @param ms The milliseconds field, expressed in universal time, to be set in the 
0867      * current date instance. This argument should be an integer between 0 and 999.
0868      * @return The millisecond representation of the adjusted date.
0869      * @see #setMilliseconds(Object)
0870      * @see jsx.core.DateLikes#setUTCMilliseconds(DateLike, Object)
0871      * @since 1.0
0872      * @javascript Re-compilers must convert the instance invocation of this method directly 
0873      * into a JavaScript invocation on its current date instance without changing the 
0874      * method name, but expanding variable arguments, if any, into comma-separated values. 
0875      */
0876     public final Number setUTCMilliseconds(Object ms) {
0877         return call(setUTCMilliseconds, ms);
0878     }
0879     /**
0880      * <p>Sets the seconds field of the current date instance, using local time.</p>
0881      * @param sec An integer between 0 and 59 that is set as the seconds value for the 
0882      * current date instance.
0883      * @return The millisecond representation of the adjusted date. Prior to ECMAScript 
0884      * standardization, this method returns nothing.
0885      * @see #setUTCSeconds(Object)
0886      * @see #setSeconds(Object, Object)
0887      * @see jsx.core.DateLikes#setSeconds(DateLike, Object)
0888      * @since 1.0
0889      * @javascript Re-compilers must convert the instance invocation of this method directly 
0890      * into a JavaScript invocation on its current date instance without changing the 
0891      * method name, but expanding variable arguments, if any, into comma-separated values. 
0892      */
0893     public final Number setSeconds(Object sec) {
0894         return call(setSeconds, sec);
0895     }
0896     /**
0897      * <p>Sets the seconds field of the current date instance, using universal time.</p>
0898      * @param sec The seconds field, expressed in universal time, to be set in the current 
0899      * date instance. This argument should be an integer between 0 and 59.
0900      * @return The millisecond representation of the adjusted date.
0901      * @see #setSeconds(Object)
0902      * @see #setUTCSeconds(Object, Object)
0903      * @see jsx.core.DateLikes#setUTCSeconds(DateLike, Object)
0904      * @since 1.0
0905      * @javascript Re-compilers must convert the instance invocation of this method directly 
0906      * into a JavaScript invocation on its current date instance without changing the 
0907      * method name, but expanding variable arguments, if any, into comma-separated values. 
0908      */
0909     public final Number setUTCSeconds(Object sec) {
0910         return call(setUTCSeconds, sec);
0911     }
0912     /**
0913      * <p>Sets the seconds field and optionally the milliseconds field of the current date 
0914      * instance, using local .</p>
0915      * @param sec An integer between 0 and 59 that is set as the seconds value for the 
0916      * current date instance.
0917      * @param ms An optional integer, between 0 and 999, that is used as the new value 
0918      * in local time of the milliseconds field of the current date instance. This argument 
0919      * is not supported prior to ECMAScript standardization.
0920      * @return The millisecond representation of the adjusted date. Prior to ECMAScript 
0921      * standardization, this method returns nothing.
0922      * @see #setUTCSeconds(Object, Object)
0923      * @see #setSeconds(Object)
0924      * @see jsx.core.DateLikes#setSeconds(DateLike, Object, Object)
0925      * @since 1.0
0926      * @javascript Re-compilers must convert the instance invocation of this method directly 
0927      * into a JavaScript invocation on its current date instance without changing the 
0928      * method name, but expanding variable arguments, if any, into comma-separated values. 
0929      */
0930     public final Number setSeconds(Object sec, Object ms) {
0931         return call(setSeconds, new Vars<Object>().add(sec).add(ms));
0932     }
0933     /**
0934      * <p>Sets the seconds field and optionally the milliseconds field of the current date 
0935      * instance, using universal time.</p>
0936      * @param sec The seconds field, expressed in universal time, to be set in the current 
0937      * date instance. This argument should be an integer between 0 and 59.
0938      * @param ms An optional integer, between 0 and 999, that is used as the new value 
0939      * in universal time of the milliseconds field of the current date instance.
0940      * @return The millisecond representation of the adjusted date.
0941      * @see #setSeconds(Object, Object)
0942      * @see #setUTCSeconds(Object)
0943      * @see jsx.core.DateLikes#setUTCSeconds(DateLike, Object, Object)
0944      * @since 1.0
0945      * @javascript Re-compilers must convert the instance invocation of this method directly 
0946      * into a JavaScript invocation on its current date instance without changing the 
0947      * method name, but expanding variable arguments, if any, into comma-separated values. 
0948      */
0949     public final Number setUTCSeconds(Object sec, Object ms) {
0950         return call(setUTCSeconds, new Vars<Object>().add(sec).add(ms));
0951     }
0952     /**
0953      * <p>Sets the minutes field of the current date instance, using local time.</p>
0954      * @param min An optional integer, between 0 and 59, that is used as the new value 
0955      * in local time of the minutes field of the current date instance.
0956      * @return The millisecond representation of the adjusted date. 
0957      * Prior to ECMAScript standardization, this method returns nothing.
0958      * @see #setUTCMinutes(Object)
0959      * @see #setMinutes(Object, Object)
0960      * @see #setMinutes(Object, Object, Object)
0961      * @see jsx.core.DateLikes#setMinutes(DateLike, Object)
0962      * @since 1.0
0963      * @javascript Re-compilers must convert the instance invocation of this method directly 
0964      * into a JavaScript invocation on its current date instance without changing the 
0965      * method name, but expanding variable arguments, if any, into comma-separated values. 
0966      */
0967     public final Number setMinutes(Object min) {
0968         return call(setMinutes, min);
0969     }
0970     /**
0971      * <p>Sets the minutes field of the current date instance, using universal time.</p>
0972      * @param min An optional integer, between 0 and 59, that is used as the new value 
0973      * in universal time of the minutes field of the current date instance.
0974      * @return The millisecond representation of the adjusted date. 
0975      * Prior to ECMAScript standardization, this method returns nothing.
0976      * @see #setMinutes(Object)
0977      * @see #setUTCMinutes(Object, Object)
0978      * @see #setUTCMinutes(Object, Object, Object)
0979      * @see jsx.core.DateLikes#setUTCMinutes(DateLike, Object)
0980      * @since 1.0
0981      * @javascript Re-compilers must convert the instance invocation of this method directly 
0982      * into a JavaScript invocation on its current date instance without changing the 
0983      * method name, but expanding variable arguments, if any, into comma-separated values. 
0984      */
0985     public final Number setUTCMinutes(Object min) {
0986         return call(setUTCMinutes, min);
0987     }
0988     /**
0989      * <p>Sets the minutes field and optionally the seconds field of the current date 
0990      * instance, using local time.</p>
0991      * @param min An optional integer, between 0 and 59, that is used as the new value 
0992      * in local time of the minutes field of the current date instance. This argument is 
0993      * not supported prior to ECMAScript standardization.
0994      * @param sec An optional integer, between 0 and 59, that is used as the new value 
0995      * in local time of the seconds field of the current date instance. This argument is 
0996      * not supported prior to ECMAScript standardization.
0997      * @return The millisecond representation of the adjusted date. 
0998      * Prior to ECMAScript standardization, this method returns nothing.
0999      * @see #setUTCMinutes(Object, Object)
1000      * @see #setMinutes(Object)
1001      * @see #setMinutes(Object, Object, Object)
1002      * @see jsx.core.DateLikes#setMinutes(DateLike, Object, Object)
1003      * @since 1.0
1004      * @javascript Re-compilers must convert the instance invocation of this method directly 
1005      * into a JavaScript invocation on its current date instance without changing the 
1006      * method name, but expanding variable arguments, if any, into comma-separated values. 
1007      */
1008     public final Number setMinutes(Object min, Object sec) {
1009         return call(setMinutes, new Vars<Object>().add(min).add(sec));
1010     }
1011     /**
1012      * <p>Sets the minutes field and optionally the seconds field of the current date 
1013      * instance, using universal time.</p>
1014      * @param min An optional integer, between 0 and 59, that is used as the new value 
1015      * in universal time of the minutes field of the current date instance.
1016      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1017      * in universal time of the seconds field of the current date instance.
1018      * @return The millisecond representation of the adjusted date. 
1019      * Prior to ECMAScript standardization, this method returns nothing.
1020      * @see #setMinutes(Object, Object)
1021      * @see #setUTCMinutes(Object)
1022      * @see #setUTCMinutes(Object, Object, Object)
1023      * @see jsx.core.DateLikes#setUTCMinutes(DateLike, Object, Object)
1024      * @since 1.0
1025      * @javascript Re-compilers must convert the instance invocation of this method directly 
1026      * into a JavaScript invocation on its current date instance without changing the 
1027      * method name, but expanding variable arguments, if any, into comma-separated values. 
1028      */
1029     public final Number setUTCMinutes(Object min, Object sec) {
1030         return call(setUTCMinutes, new Vars<Object>().add(min).add(sec));
1031     }
1032     /**
1033      * <p>Sets the minutes field and optionally the seconds and milliseconds fields of the 
1034      * current date instance, using local time.</p>
1035      * @param min An optional integer, between 0 and 59, that is used as the new value 
1036      * in local time of the minutes field of the current date instance. This argument is 
1037      * not supported prior to ECMAScript standardization.
1038      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1039      * in local time of the seconds field of the current date instance. This argument is 
1040      * not supported prior to ECMAScript standardization.
1041      * @param ms An optional integer, between 0 and 999, that is used as the new value 
1042      * in local time of the milliseconds field of the current date instance. This argument 
1043      * is not supported prior to ECMAScript standardization.
1044      * @return The millisecond representation of the adjusted date. 
1045      * Prior to ECMAScript standardization, this method returns nothing.
1046      * @see #setUTCMinutes(Object, Object, Object)
1047      * @see #setMinutes(Object)
1048      * @see #setMinutes(Object, Object)
1049      * @see jsx.core.DateLikes#setMinutes(DateLike, Object, Object, Object)
1050      * @since 1.0
1051      * @javascript Re-compilers must convert the instance invocation of this method directly 
1052      * into a JavaScript invocation on its current date instance without changing the 
1053      * method name, but expanding variable arguments, if any, into comma-separated values. 
1054      */
1055     public final Number setMinutes(Object min, Object sec, Object ms) {
1056         return call(setMinutes, new Vars<Object>().add(min).add(sec).add(ms));
1057     }
1058     /**
1059      * <p>Sets the minutes field and optionally the seconds and milliseconds fields of the 
1060      * current date instance, using universal time.</p>
1061      * @param min An optional integer, between 0 and 59, that is used as the new value 
1062      * in universal time of the minutes field of the current date instance.
1063      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1064      * in universal time of the seconds field of the current date instance.
1065      * @param ms An optional integer, between 0 and 999, that is used as the new value 
1066      * in universal time of the milliseconds field of the current date instance.
1067      * @return The millisecond representation of the adjusted date. 
1068      * Prior to ECMAScript standardization, this method returns nothing.
1069      * @see #setMinutes(Object, Object, Object)
1070      * @see #setUTCMinutes(Object)
1071      * @see #setUTCMinutes(Object, Object)
1072      * @see jsx.core.DateLikes#setUTCMinutes(DateLike, Object, Object, Object)
1073      * @since 1.0
1074      * @javascript Re-compilers must convert the instance invocation of this method directly 
1075      * into a JavaScript invocation on its current date instance without changing the 
1076      * method name, but expanding variable arguments, if any, into comma-separated values. 
1077      */
1078     public final Number setUTCMinutes(Object min, Object sec, Object ms) {
1079         return call(setUTCMinutes, new Vars<Object>().add(min).add(sec).add(ms));
1080     }
1081     /**
1082      * <p>Sets the hour field of the current date instance, using local time.</p>
1083      * @param hr An integer between 0 (midnight) and 23 (11 p.m.) local time that is set 
1084      * as the new hours value of the current date instance.
1085      * @return The millisecond representation of the adjusted date. 
1086      * Prior to ECMAScript standardization, this method returns nothing.
1087      * @see #setUTCHours(Object)
1088      * @see #setHours(Object, Object)
1089      * @see #setHours(Object, Object, Object)
1090      * @see #setHours(Object, Object, Object, Object)
1091      * @see jsx.core.DateLikes#setHours(DateLike, Object)
1092      * @since 1.0
1093      * @javascript Re-compilers must convert the instance invocation of this method directly 
1094      * into a JavaScript invocation on its current date instance without changing the 
1095      * method name, but expanding variable arguments, if any, into comma-separated values. 
1096      */
1097     public final Number setHours(Object hr) {
1098         return call(setHours, hr);
1099     }
1100     /**
1101      * <p>Sets the hour field of the current date instance, using universal time.</p>
1102      * @param hr The hours field, expressed in universal time, to be set in the current 
1103      * date instance. This argument should be an integer between 0 (midnight) and 23 
1104      * (11 p.m.).
1105      * @return The millisecond representation of the adjusted date. 
1106      * @see #setHours(Object)
1107      * @see #setUTCHours(Object, Object)
1108      * @see #setUTCHours(Object, Object, Object)
1109      * @see #setUTCHours(Object, Object, Object, Object)
1110      * @see jsx.core.DateLikes#setUTCHours(DateLike, Object)
1111      * @since 1.0
1112      * @javascript Re-compilers must convert the instance invocation of this method directly 
1113      * into a JavaScript invocation on its current date instance without changing the 
1114      * method name, but expanding variable arguments, if any, into comma-separated values. 
1115      */
1116     public final Number setUTCHours(Object hr) {
1117         return call(setUTCHours, hr);
1118     }
1119     /**
1120      * <p>Sets the hour field and optionally the minutes field of the current date 
1121      * instance, using local time.</p>
1122      * @param hr An integer between 0 (midnight) and 23 (11 p.m.) local time that is set 
1123      * as the new hours value of the current date instance.
1124      * @param min An optional integer, between 0 and 59, that is used as the new value 
1125      * in local time of the minutes field of the current date instance. This argument is 
1126      * not supported prior to ECMAScript standardization.
1127      * @return The millisecond representation of the adjusted date. 
1128      * Prior to ECMAScript standardization, this method returns nothing.
1129      * @see #setUTCHours(Object, Object)
1130      * @see #setHours(Object)
1131      * @see #setHours(Object, Object, Object)
1132      * @see #setHours(Object, Object, Object, Object)
1133      * @see jsx.core.DateLikes#setHours(DateLike, Object, Object)
1134      * @since 1.0
1135      * @javascript Re-compilers must convert the instance invocation of this method directly 
1136      * into a JavaScript invocation on its current date instance without changing the 
1137      * method name, but expanding variable arguments, if any, into comma-separated values. 
1138      */
1139     public final Number setHours(Object hr, Object min) {
1140         return call(setHours, new Vars<Object>().add(hr).add(min));
1141     }
1142     /**
1143      * <p>Sets the hour field and optionally the minutes field of the current date 
1144      * instance, using universal time.</p>
1145      * @param hr The hours field, expressed in universal time, to be set in the current 
1146      * date instance. This argument should be an integer between 0 (midnight) and 23 
1147      * (11 p.m.).
1148      * @param min An optional integer, between 0 and 59, that is used as the new value 
1149      * in universal time of the minutes field of the current date instance.
1150      * @return The millisecond representation of the adjusted date. 
1151      * @see #setHours(Object, Object)
1152      * @see #setUTCHours(Object)
1153      * @see #setUTCHours(Object, Object, Object)
1154      * @see #setUTCHours(Object, Object, Object, Object)
1155      * @see jsx.core.DateLikes#setUTCHours(DateLike, Object, Object)
1156      * @since 1.0
1157      * @javascript Re-compilers must convert the instance invocation of this method directly 
1158      * into a JavaScript invocation on its current date instance without changing the 
1159      * method name, but expanding variable arguments, if any, into comma-separated values. 
1160      */
1161     public final Number setUTCHours(Object hr, Object min) {
1162         return call(setUTCHours, new Vars<Object>().add(hr).add(min));
1163     }
1164     /**
1165      * <p>Sets the hour field and optionally the minutes and seconds fields of the current 
1166      * date instance, using local time.</p>
1167      * @param hr An integer between 0 (midnight) and 23 (11 p.m.) local time that is set 
1168      * as the new hours value of the current date instance.
1169      * @param min An optional integer, between 0 and 59, that is used as the new value 
1170      * in local time of the minutes field of the current date instance. This argument is 
1171      * not supported prior to ECMAScript standardization.
1172      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1173      * in local time of the seconds field of the current date instance. This argument is 
1174      * not supported prior to ECMAScript standardization.
1175      * @return The millisecond representation of the adjusted date. 
1176      * Prior to ECMAScript standardization, this method returns nothing.
1177      * @see #setUTCHours(Object, Object, Object)
1178      * @see #setHours(Object)
1179      * @see #setHours(Object, Object)
1180      * @see #setHours(Object, Object, Object, Object)
1181      * @see jsx.core.DateLikes#setHours(DateLike, Object, Object, Object)
1182      * @since 1.0
1183      * @javascript Re-compilers must convert the instance invocation of this method directly 
1184      * into a JavaScript invocation on its current date instance without changing the 
1185      * method name, but expanding variable arguments, if any, into comma-separated values. 
1186      */
1187     public final Number setHours(Object hr, Object min, Object sec) {
1188         return call(setHours, new Vars<Object>().add(hr).add(min).add(sec));
1189     }
1190     /**
1191      * <p>Sets the hour field and optionally the minutes and seconds fields of the current 
1192      * date instance, using universal time.</p>
1193      * @param hr The hours field, expressed in universal time, to be set in the current 
1194      * date instance. This argument should be an integer between 0 (midnight) and 23 
1195      * (11 p.m.).
1196      * @param min An optional integer, between 0 and 59, that is used as the new value 
1197      * in universal time of the minutes field of the current date instance.
1198      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1199      * in universal time of the seconds field of the current date instance.
1200      * @return The millisecond representation of the adjusted date.
1201      * @see #setHours(Object, Object, Object)
1202      * @see #setUTCHours(Object)
1203      * @see #setUTCHours(Object, Object)
1204      * @see #setUTCHours(Object, Object, Object, Object)
1205      * @see jsx.core.DateLikes#setUTCHours(DateLike, Object, Object, Object)
1206      * @since 1.0
1207      * @javascript Re-compilers must convert the instance invocation of this method directly 
1208      * into a JavaScript invocation on its current date instance without changing the 
1209      * method name, but expanding variable arguments, if any, into comma-separated values. 
1210      */
1211     public final Number setUTCHours(Object hr, Object min, Object sec) {
1212         return call(setUTCHours, new Vars<Object>().add(hr).add(min).add(sec));
1213     }
1214     /**
1215      * <p>Sets the hour field and optionally the minutes, seconds, and milliseconds fields 
1216      * of the current date instance, using local time.</p>
1217      * @param hr An integer between 0 (midnight) and 23 (11 p.m.) local time that is set 
1218      * as the new hours value of the current date instance.
1219      * @param min An optional integer, between 0 and 59, that is used as the new value 
1220      * in local time of the minutes field of the current date instance. This argument is 
1221      * not supported prior to ECMAScript standardization.
1222      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1223      * in local time of the seconds field of the current date instance. This argument is 
1224      * not supported prior to ECMAScript standardization.
1225      * @param ms An optional integer, between 0 and 999, that is used as the new value 
1226      * in local time of the milliseconds field of the current date instance. This argument 
1227      * is not supported prior to ECMAScript standardization.
1228      * @return The millisecond representation of the adjusted date. 
1229      * Prior to ECMAScript standardization, this method returns nothing.
1230      * @see #setUTCHours(Object, Object, Object, Object)
1231      * @see #setHours(Object)
1232      * @see #setHours(Object, Object)
1233      * @see #setHours(Object, Object, Object)
1234      * @see jsx.core.DateLikes#setHours(DateLike, Object, Object, Object, Object)
1235      * @since 1.0
1236      * @javascript Re-compilers must convert the instance invocation of this method directly 
1237      * into a JavaScript invocation on its current date instance without changing the 
1238      * method name, but expanding variable arguments, if any, into comma-separated values. 
1239      */
1240     public final Number setHours(Object hr, Object min, Object sec, Object ms) {
1241         return call(setHours, new Vars<Object>().add(hr).add(min).add(sec).add(ms));
1242     }
1243     /**
1244      * <p>Sets the hour field and optionally the minutes, seconds, and milliseconds fields 
1245      * of the current date instance, using universal time.</p>
1246      * @param hr The hours field, expressed in universal time, to be set in the current 
1247      * date instance. This argument should be an integer between 0 (midnight) and 23 
1248      * (11 p.m.).
1249      * @param min An optional integer, between 0 and 59, that is used as the new value 
1250      * in universal time of the minutes field of the current date instance.
1251      * @param sec An optional integer, between 0 and 59, that is used as the new value 
1252      * in universal time of the seconds field of the current date instance.
1253      * @param ms An optional integer, between 0 and 999, that is used as the new value 
1254      * in universal time of the milliseconds field of the current date instance.
1255      * @return The millisecond representation of the adjusted date.
1256      * @see #setHours(Object, Object, Object, Object)
1257      * @see #setUTCHours(Object)
1258      * @see #setUTCHours(Object, Object)
1259      * @see #setUTCHours(Object, Object, Object)
1260      * @see jsx.core.DateLikes#setUTCHours(DateLike, Object, Object, Object, Object)
1261      * @since 1.0
1262      * @javascript Re-compilers must convert the instance invocation of this method directly 
1263      * into a JavaScript invocation on its current date instance without changing the 
1264      * method name, but expanding variable arguments, if any, into comma-separated values. 
1265      */
1266     public final Number setUTCHours(Object hr, Object min, Object sec, Object ms) {
1267         return call(setUTCHours, new Vars<Object>().add(hr).add(min).add(sec).add(ms));
1268     }
1269     /**
1270      * <p>Sets the day of the month field of the current date instance, using local time.</p>
1271      * @param day An integer between 1 and 31 that is used as the new value in local time 
1272      * of the day-of-the-month field of the current date instance.
1273      * @return The millisecond representation of the adjusted date. 
1274      * Prior to ECMAScript standardization, this method returns nothing.
1275      * @see #setUTCDate(Object)
1276      * @see jsx.core.DateLikes#setDate(DateLike, Object)
1277      * @since 1.0
1278      * @javascript Re-compilers must convert the instance invocation of this method directly 
1279      * into a JavaScript invocation on its current date instance without changing the 
1280      * method name, but expanding variable arguments, if any, into comma-separated values. 
1281      */
1282     public final Number setDate(Object day) {
1283         return call(setDate, day);
1284     }
1285     /**
1286      * <p>Sets the day of the month field of the current date instance, using universal 
1287      * time.</p>
1288      * @param day The day of the month, expressed in universal time, to be set in the 
1289      * current date instance. This argument should be an integer between 1 and 31.
1290      * @return The millisecond representation of the adjusted date. 
1291      * @see #setDate(Object)
1292      * @see jsx.core.DateLikes#setUTCDate(DateLike, Object)
1293      * @since 1.0
1294      * @javascript Re-compilers must convert the instance invocation of this method directly 
1295      * into a JavaScript invocation on its current date instance without changing the 
1296      * method name, but expanding variable arguments, if any, into comma-separated values. 
1297      */
1298     public final Number setUTCDate(Object day) {
1299         return call(setUTCDate, day);
1300     }
1301     /**
1302      * <p>Sets the month field of the current date instance, using local time.</p>
1303      * @param mo An integer between 0 ( January) and 11 (December) that is set as the month 
1304      * value in local time for the current date instance. Note that months are numbered 
1305      * beginning with 0, while days within the month are numbered beginning with 1.
1306      * @return The millisecond representation of the adjusted date. 
1307      * Prior to ECMAScript standardization, this method returns nothing.
1308      * @see #setUTCMonth(Object)
1309      * @see #setMonth(Object, Object)
1310      * @see jsx.core.DateLikes#setMonth(DateLike, Object)
1311      * @since 1.0
1312      * @javascript Re-compilers must convert the instance invocation of this method directly 
1313      * into a JavaScript invocation on its current date instance without changing the 
1314      * method name, but expanding variable arguments, if any, into comma-separated values. 
1315      */
1316     public final Number setMonth(Object mo) {
1317         return call(setMonth, mo);
1318     }
1319     /**
1320      * <p>Sets the month field of the current date instance, using universal time.</p>
1321      * @param mo The month, expressed in universal time, to be set in the current date
1322      * instance. This argument should be an integer between 0 (January) and 11 (December). 
1323      * Note that months are numbered beginning with 0, while days within the month are 
1324      * numbered beginning with 1.
1325      * @return The millisecond representation of the adjusted date. 
1326      * @see #setMonth(Object)
1327      * @see #setUTCMonth(Object, Object)
1328      * @see jsx.core.DateLikes#setUTCMonth(DateLike, Object)
1329      * @since 1.0
1330      * @javascript Re-compilers must convert the instance invocation of this method directly 
1331      * into a JavaScript invocation on its current date instance without changing the 
1332      * method name, but expanding variable arguments, if any, into comma-separated values. 
1333      */
1334     public final Number setUTCMonth(Object mo) {
1335         return call(setUTCMonth, mo);
1336     }
1337     /**
1338      * <p>Sets the month field and optionally the day of the month of the current date 
1339      * instance, using local time.</p>
1340      * @param mo An integer between 0 ( January) and 11 (December) that is set as the month 
1341      * value in local time for the current date instance. Note that months are numbered 
1342      * beginning with 0, while days within the month are numbered beginning with 1.
1343      * @param day An optional integer between 1 and 31 that is used as the new value in 
1344      * local time of the day-of-the-month field of the current date instance. This argument 
1345      * is not supported prior to ECMAScript standardization.
1346      * @return The millisecond representation of the adjusted date. 
1347      * Prior to ECMAScript standardization, this method returns nothing.
1348      * @see #setUTCMonth(Object, Object)
1349      * @see #setMonth(Object)
1350      * @see jsx.core.DateLikes#setMonth(DateLike, Object, Object)
1351      * @since 1.0
1352      * @javascript Re-compilers must convert the instance invocation of this method directly 
1353      * into a JavaScript invocation on its current date instance without changing the 
1354      * method name, but expanding variable arguments, if any, into comma-separated values. 
1355      */
1356     public final Number setMonth(Object mo, Object day) {
1357         return call(setMonth, new Vars<Object>().add(mo).add(day));
1358     }
1359     /**
1360      * <p>Sets the month field and optionally the day of the month of the current date 
1361      * instance, using universal time.</p>
1362      * @param mo The month, expressed in universal time, to be set in the current date
1363      * instance. This argument should be an integer between 0 (January) and 11 (December). 
1364      * Note that months are numbered beginning with 0, while days within the month are 
1365      * numbered beginning with 1.
1366      * @param day An optional integer between 1 and 31 that is used as the new value in 
1367      * universal time of the day-of-the-month field of the current date instance.
1368      * @return The millisecond representation of the adjusted date. 
1369      * @see #setMonth(Object, Object)
1370      * @see #setUTCMonth(Object)
1371      * @see jsx.core.DateLikes#setUTCMonth(DateLike, Object, Object)
1372      * @since 1.0
1373      * @javascript Re-compilers must convert the instance invocation of this method directly 
1374      * into a JavaScript invocation on its current date instance without changing the 
1375      * method name, but expanding variable arguments, if any, into comma-separated values. 
1376      */
1377     public final Number setUTCMonth(Object mo, Object day) {
1378         return call(setUTCMonth, new Vars<Object>().add(mo).add(day));
1379     }
1380     /**
1381      * <p>Sets the year field of the current date instance, using local time.</p>
1382      * @param yr The year, expressed in local time, to be set in the current date instance. 
1383      * This argument should be an integer that includes the century, such as 1999; it 
1384      * should not be an abbreviation, such as 99.
1385      * @return The millisecond representation of the adjusted date. 
1386      * @see #setUTCFullYear(Object)
1387      * @see #setFullYear(Object, Object)
1388      * @see #setFullYear(Object, Object, Object)
1389      * @see jsx.core.DateLikes#setFullYear(DateLike, Object)
1390      * @since 1.0
1391      * @javascript Re-compilers must convert the instance invocation of this method directly 
1392      * into a JavaScript invocation on its current date instance without changing the 
1393      * method name, but expanding variable arguments, if any, into comma-separated values. 
1394      */
1395     public final Number setFullYear(Object yr) {
1396         return call(setFullYear, yr);
1397     }
1398     /**
1399      * <p>Sets the year field of the current date instance, using universal time.</p>
1400      * @param yr The year, expressed in universal time, to be set in the current date 
1401      * instance. This argument should be an integer that includes the century, such as 
1402      * 1999, not an abbreviation, such as 99.
1403      * @return The millisecond representation of the adjusted date. 
1404      * @see #setFullYear(Object)
1405      * @see #setUTCFullYear(Object, Object)
1406      * @see #setUTCFullYear(Object, Object, Object)
1407      * @see jsx.core.DateLikes#setUTCFullYear(DateLike, Object)
1408      * @since 1.0
1409      * @javascript Re-compilers must convert the instance invocation of this method directly 
1410      * into a JavaScript invocation on its current date instance without changing the 
1411      * method name, but expanding variable arguments, if any, into comma-separated values. 
1412      */
1413     public final Number setUTCFullYear(Object yr) {
1414         return call(setUTCFullYear, yr);
1415     }
1416     /**
1417      * <p>Sets the year and optionally month fields of the current date instance, using 
1418      * local time.</p>
1419      * @param yr The year, expressed in local time, to be set in the current date instance. 
1420      * This argument should be an integer that includes the century, such as 1999; it 
1421      * should not be an abbreviation, such as 99.
1422      * @param mo An optional integer between 0 and 11 that is used as the new value in 
1423      * local time of the month field of the current date instance.
1424      * @return The millisecond representation of the adjusted date. 
1425      * @see #setUTCFullYear(Object, Object)
1426      * @see #setFullYear(Object)
1427      * @see #setFullYear(Object, Object, Object)
1428      * @see jsx.core.DateLikes#setFullYear(DateLike, Object, Object)
1429      * @since 1.0
1430      * @javascript Re-compilers must convert the instance invocation of this method directly 
1431      * into a JavaScript invocation on its current date instance without changing the 
1432      * method name, but expanding variable arguments, if any, into comma-separated values. 
1433      */
1434     public final Number setFullYear(Object yr, Object mo) {
1435         return call(setFullYear, new Vars<Object>().add(yr).add(mo));
1436     }
1437     /**
1438      * <p>Sets the year and optionally month fields of the current date instance, using 
1439      * universal time.</p>
1440      * @param yr The year, expressed in universal time, to be set in the current date 
1441      * instance. This argument should be an integer that includes the century, such as 
1442      * 1999, not an abbreviation, such as 99.
1443      * @param mo An optional integer between 0 and 11 that is used as the new value in 
1444      * universal time of the month field of the current date instance. Note that months 
1445      * are numbered beginning with 0, while days within the month are numbered beginning 
1446      * with 1.
1447      * @return The millisecond representation of the adjusted date. 
1448      * @see #setFullYear(Object, Object)
1449      * @see #setUTCFullYear(Object)
1450      * @see #setUTCFullYear(Object, Object, Object)
1451      * @see jsx.core.DateLikes#setUTCFullYear(DateLike, Object, Object)
1452      * @since 1.0
1453      * @javascript Re-compilers must convert the instance invocation of this method directly 
1454      * into a JavaScript invocation on its current date instance without changing the 
1455      * method name, but expanding variable arguments, if any, into comma-separated values. 
1456      */
1457     public final Number setUTCFullYear(Object yr, Object mo) {
1458         return call(setUTCFullYear, new Vars<Object>().add(yr).add(mo));
1459     }
1460     /**
1461      * <p>Sets the year and optionally month and day fields of the current date instance, 
1462      * using local time.</p>
1463      * @param yr The year, expressed in local time, to be set in the current date instance. 
1464      * This argument should be an integer that includes the century, such as 1999; it 
1465      * should not be an abbreviation, such as 99.
1466      * @param mo An optional integer between 0 and 11 that is used as the new value in 
1467      * local time of the month field of the current date instance.
1468      * @param day An optional integer between 1 and 31 that is used as the new value in 
1469      * local time of the day-of-the-month field of the current date instance.
1470      * @return The millisecond representation of the adjusted date. 
1471      * @see #setUTCFullYear(Object, Object, Object)
1472      * @see #setFullYear(Object)
1473      * @see #setFullYear(Object, Object)
1474      * @see jsx.core.DateLikes#setFullYear(DateLike, Object, Object, Object)
1475      * @since 1.0
1476      * @javascript Re-compilers must convert the instance invocation of this method directly 
1477      * into a JavaScript invocation on its current date instance without changing the 
1478      * method name, but expanding variable arguments, if any, into comma-separated values. 
1479      */
1480     public final Number setFullYear(Object yr, Object mo, Object day) {
1481         return call(setFullYear, new Vars<Object>().add(yr).add(mo).add(day));
1482     }
1483     /**
1484      * <p>Sets the year and optionally month and day fields of the current date instance, 
1485      * using universal time.</p>
1486      * @param yr The year, expressed in universal time, to be set in the current date 
1487      * instance. This argument should be an integer that includes the century, such as 
1488      * 1999, not an abbreviation, such as 99.
1489      * @param mo An optional integer between 0 and 11 that is used as the new value in 
1490      * universal time of the month field of the current date instance. Note that months 
1491      * are numbered beginning with 0, while days within the month are numbered beginning 
1492      * with 1.
1493      * @param day An optional integer between 1 and 31 that is used as the new value in 
1494      * universal time of the day-of-the-month field of the current date instance.
1495      * @return The millisecond representation of the adjusted date. 
1496      * @see #setFullYear(Object, Object, Object)
1497      * @see #setUTCFullYear(Object)
1498      * @see #setUTCFullYear(Object, Object)
1499      * @see jsx.core.DateLikes#setUTCFullYear(DateLike, Object, Object, Object)
1500      * @since 1.0
1501      * @javascript Re-compilers must convert the instance invocation of this method directly 
1502      * into a JavaScript invocation on its current date instance without changing the 
1503      * method name, but expanding variable arguments, if any, into comma-separated values. 
1504      */
1505     public final Number setUTCFullYear(Object yr, Object mo, Object day) {
1506         return call(setUTCFullYear, new Vars<Object>().add(yr).add(mo).add(day));
1507     }
1508     /**
1509      * <p>Returns a string that represents the date portion of the current date instance, 
1510      * expressed in the local time zone.</p>
1511      * @return An implementation-dependent, human-readable string representation of the 
1512      * date portion of the current date instance, expressed in the local time zone.
1513      * @see #toLocaleDateString()
1514      * @see #toLocaleString()
1515      * @see #toLocaleTimeString()
1516      * @see #toString()
1517      * @see #toTimeString()
1518      * @see jsx.core.DateLikes#toDateString(DateLike)
1519      * @since 1.0
1520      * @javascript Re-compilers must convert the instance invocation of this method directly 
1521      * into a JavaScript invocation on its current date instance without changing the 
1522      * method name, but expanding variable arguments, if any, into comma-separated values. 
1523      */
1524     public final String toDateString() {
1525         return call(toDateString);
1526     }
1527     /**
1528      * <p>Returns a string that represents the time portion of the current date instance, 
1529      * expressed in the local time zone.</p>
1530      * @return An implementation-dependent, human-readable string representation of the 
1531      * time portion of the current date instance, expressed in the local time zone.
1532      * @see #toDateString()
1533      * @see #toLocaleDateString()
1534      * @see #toLocaleString()
1535      * @see #toLocaleTimeString()
1536      * @see #toString()
1537      * @see jsx.core.DateLikes#toTimeString(DateLike)
1538      * @since 1.0
1539      * @javascript Re-compilers must convert the instance invocation of this method directly 
1540      * into a JavaScript invocation on its current date instance without changing the 
1541      * method name, but expanding variable arguments, if any, into comma-separated values. 
1542      */
1543     public final String toTimeString() {
1544         return call(toTimeString);
1545     }
1546     /**
1547      * <p>Returns a string that represents the date portion of the current date instance, 
1548      * expressed in the local time zone, using the local date formatting conventions.</p>
1549      * @return An implementation-dependent, human-readable string representation of the 
1550      * date portion of the current date instance, expressed in the local time zone and 
1551      * formatted according to local conventions.
1552      * @see #toDateString()
1553      * @see #toLocaleString()
1554      * @see #toLocaleTimeString()
1555      * @see #toString()
1556      * @see #toTimeString()
1557      * @see jsx.core.DateLikes#toLocaleDateString(DateLike)
1558      * @since 1.0
1559      * @javascript Re-compilers must convert the instance invocation of this method directly 
1560      * into a JavaScript invocation on its current date instance without changing the 
1561      * method name, but expanding variable arguments, if any, into comma-separated values. 
1562      */
1563     public final String toLocaleDateString() {
1564         return call(toLocaleDateString);
1565     }
1566     /**
1567      * <p>Returns a string that represents the time portion of the current date instance, 
1568      * expressed in the local time zone, using the local time formatting conventions.</p>
1569      * @return An implementation-dependent, human-readable string representation of the 
1570      * time portion of the current date instance, expressed in the local time zone and 
1571      * formatted according to local conventions.
1572      * @see #toDateString()
1573      * @see #toLocaleDateString()
1574      * @see #toLocaleString()
1575      * @see #toString()
1576      * @see #toTimeString()
1577      * @see jsx.core.DateLikes#toLocaleTimeString(DateLike)
1578      * @since 1.0
1579      * @javascript Re-compilers must convert the instance invocation of this method directly 
1580      * into a JavaScript invocation on its current date instance without changing the 
1581      * method name, but expanding variable arguments, if any, into comma-separated values. 
1582      */
1583     public final String toLocaleTimeString() {
1584         return call(toLocaleTimeString);
1585     }
1586     /**
1587      * <p>Converts the current date instance to a string, using universal time.</p>
1588      * @return A human-readable string representation, expressed in universal time, of the 
1589      * current date instance.
1590      * @see #toLocaleString()
1591      * @see #toString()
1592      * @see jsx.core.DateLikes#toUTCString(DateLike)
1593      * @since 1.0
1594      * @javascript Re-compilers must convert the instance invocation of this method directly 
1595      * into a JavaScript invocation on its current date instance without changing the 
1596      * method name, but expanding variable arguments, if any, into comma-separated values. 
1597      */
1598     public final String toUTCString() {
1599         return call(toUTCString);
1600     }
1601 
1602     /**
1603      * <p>Returns the primitive value associated with the current instance, if there is one. 
1604      * This invocation returns the primitive number value associated with the current instance.</p>
1605      * @return The millisecond representation of the current date instance. The value 
1606      * returned is the same as that returned by {@link #getTime()}.
1607      * @since 1.0
1608      * @javascript Re-compilers must convert the instance invocation of this method directly 
1609      * into a JavaScript invocation on its current date instance without changing the 
1610      * method name, but expanding variable arguments, if any, into comma-separated values. 
1611      */
1612     @Override
1613     public Number valueOf() {
1614         return var().valueOf();
1615     }
1616 
1617     /**
1618      * <p>Increases the current date instance by 1 and then returns the value of the 
1619      * current date instance, resembling the pre-increment operator in JavaScript.</p>
1620      * @return The value of the current date instance increased by 1.
1621      * @since 1.0
1622      * @javascript A re-compiler is expected to replace the instance invocation of this 
1623      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1624      * <pre>++d</pre>
1625      * where <tt>d</tt> is the primitive value of the current date instance of the 
1626      * invocation of this method.
1627      */
1628     public Number inc() {
1629         return var().inc();
1630     }
1631 
1632     /**
1633      * <p>Decreases the current date instance by 1 and then returns the value of the 
1634      * current date instance, resembling the pre-decrement operator in JavaScript.</p>
1635      * @return The value of the current date instance decreased by 1.
1636      * @since 1.0
1637      * @javascript A re-compiler is expected to replace the instance invocation of this 
1638      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1639      * <pre>--d</pre>
1640      * where <tt>d</tt> is the primitive value of the current date instance of the 
1641      * invocation of this method.
1642      */
1643     public Number dec() {
1644         return var().dec();
1645     }
1646 
1647     /**
1648      * <p>Returns the primitive value of the current date instance and then increases the 
1649      * current date instance by 1, resembling the post-increment operator in JavaScript.</p>
1650      * @return The value of the original date instance.
1651      * @since 1.0
1652      * @javascript A re-compiler is expected to replace the instance invocation of this 
1653      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1654      * <pre>d++</pre>
1655      * where <tt>d</tt> is the primitive value of the current date instance of the 
1656      * invocation of this method.
1657      */
1658     public Number incp() {
1659         return var().incp();
1660     }
1661 
1662     /**
1663      * <p>Returns the primitive value of the current date instance and then decreases the 
1664      * current date instance by 1, resembling the post-decrement operator in JavaScript.</p>
1665      * @return The value of the original date instance.
1666      * @since 1.0
1667      * @javascript A re-compiler is expected to replace the instance invocation of this 
1668      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1669      * <pre>d--</pre>
1670      * where <tt>d</tt> is the primitive value of the current date instance of the 
1671      * invocation of this method.
1672      */
1673     public Number decp() {
1674         return var().decp();
1675     }
1676 
1677     /**
1678      * <p>Adds a numeric operand to the current date instance and returns the numeric 
1679      * operand, resembling the assignment-with-addition operator in JavaScript.</p>
1680      * @param value A numeric value.
1681      * @return The numeric value of the argument.
1682      * @since 1.0
1683      * @javascript Re-compilers must replace the instance invocation of this method with the 
1684      * JavaScript expression:
1685      * <pre>d += value</pre>
1686      * where <tt>d</tt> is the primitive value of the current date instance of the 
1687      * invocation of this method.
1688      */
1689     public Number aadd(Character value) {
1690         return var().aadd(value);
1691     }
1692 
1693     /**
1694      * <p>Adds a numeric operand to the current date instance and returns the numeric 
1695      * operand, resembling the assignment-with-addition operator in JavaScript.</p>
1696      * @param value A numeric value.
1697      * @return The numeric value of the argument.
1698      * @since 1.0
1699      * @javascript Re-compilers must replace the instance invocation of this method with the 
1700      * JavaScript expression:
1701      * <pre>d += value</pre>
1702      * where <tt>d</tt> is the primitive value of the current date instance of the 
1703      * invocation of this method.
1704      */
1705     public Number aadd(Value.Character value) {
1706         return var().aadd(value);
1707     }
1708 
1709     /**
1710      * <p>Adds a numeric operand to the current date instance and returns the numeric 
1711      * operand, resembling the assignment-with-addition operator in JavaScript.</p>
1712      * @param value A numeric value.
1713      * @return The numeric value of the argument.
1714      * @since 1.0
1715      * @javascript Re-compilers must replace the instance invocation of this method with the 
1716      * JavaScript expression:
1717      * <pre>d += value</pre>
1718      * where <tt>d</tt> is the primitive value of the current date instance of the 
1719      * invocation of this method.
1720      */
1721     public Number aadd(Number value) {
1722         return var().aadd(value);
1723     }
1724 
1725     /**
1726      * <p>Adds a numeric operand to the current date instance and returns the numeric 
1727      * operand, resembling the assignment-with-addition operator in JavaScript.</p>
1728      * @param value A numeric value.
1729      * @return The numeric value of the argument.
1730      * @since 1.0
1731      * @javascript Re-compilers must replace the instance invocation of this method with the 
1732      * JavaScript expression:
1733      * <pre>d += value</pre>
1734      * where <tt>d</tt> is the primitive value of the current date instance of the 
1735      * invocation of this method.
1736      */
1737     public Number aadd(Value<? extends Number> value) {
1738         return var().aadd(value);
1739     }
1740 
1741     /**
1742      * <p>Adds a numeric operand to the current date instance and returns the numeric 
1743      * operand, resembling the assignment-with-addition operator in JavaScript.</p>
1744      * @param value A numeric value.
1745      * @return The numeric value of the argument.
1746      * @since 1.0
1747      * @javascript Re-compilers must replace the instance invocation of this method with the 
1748      * JavaScript expression:
1749      * <pre>d += value</pre>
1750      * where <tt>d</tt> is the primitive value of the current date instance of the 
1751      * invocation of this method.
1752      */
1753     public Number aadd(JsNumber value) {
1754         return var().aadd(value);
1755     }
1756 
1757     /**
1758      * <p>Subtracts a numeric operand from the current date instance and returns the numeric 
1759      * operand, resembling the assignment-with-subtraction operator in JavaScript.</p>
1760      * @param value A numeric value.
1761      * @return The numeric value of the argument.
1762      * @since 1.0
1763      * @javascript Re-compilers must replace the instance invocation of this method with the 
1764      * JavaScript expression:
1765      * <pre>d -= value</pre>
1766      * where <tt>d</tt> is the primitive value of the current date instance of the 
1767      * invocation of this method.
1768      */
1769     public Number asub(Object value) {
1770         return var().asub(value);
1771     }
1772 
1773     /**
1774      * <p>Multiplies a numeric operand to the current date instance and returns the numeric 
1775      * operand, resembling the assignment-with-multiplication operator in JavaScript.</p>
1776      * @param value A numeric value.
1777      * @return The numeric value of the argument.
1778      * @since 1.0
1779      * @javascript Re-compilers must replace the instance invocation of this method with the 
1780      * JavaScript expression:
1781      * <pre>d *= value</pre>
1782      * where <tt>d</tt> is the primitive value of the current date instance of the 
1783      * invocation of this method.
1784      */
1785     public Number amul(Object value) {
1786         return var().amul(value);
1787     }
1788 
1789     /**
1790      * <p>Divides, by a numeric operand, the current date instance and returns the numeric 
1791      * operand, resembling the assignment-with-division operator in JavaScript.</p>
1792      * @param value A numeric value.
1793      * @return The numeric value of the argument.
1794      * @since 1.0
1795      * @javascript Re-compilers must replace the instance invocation of this method with the 
1796      * JavaScript expression:
1797      * <pre>d /= value</pre>
1798      * where <tt>d</tt> is the primitive value of the current date instance of the 
1799      * invocation of this method.
1800      */
1801     public Number adiv(Object value) {
1802         return var().adiv(value);
1803     }
1804 
1805     /**
1806      * <p>Modulo operates a numeric operand onto the current date instance and returns the 
1807      * numeric operand, resembling the assignment-with-multiplication operator in 
1808      * JavaScript.</p>
1809      * @param value A numeric value.
1810      * @return The numeric value of the argument.
1811      * @since 1.0
1812      * @javascript Re-compilers must replace the instance invocation of this method with the 
1813      * JavaScript expression:
1814      * <pre>d %= value</pre>
1815      * where <tt>d</tt> is the primitive value of the current date instance of the 
1816      * invocation of this method.
1817      */
1818     public Number amod(Object value) {
1819         return var().amod(value);
1820     }
1821 
1822     /**
1823      * <p>Assignment-with-shift-left operation, resembling that of JavaScript, moves all bits in the 
1824      * current primitive instance to the left by the number of places specified in the 
1825      * second operand, which should be an integer between 0 and 31.</p>
1826      * <p>A zero is used for the new first bit, and the value of the 32nd bit is lost. 
1827      * Shifting a value left by one position is equivalent to multiplying by 2, shifting 
1828      * two positions is equivalent to multiplying by 4, etc.</p>
1829      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1830      * operation requires numeric operands that have integer values. It operate on the integer 
1831      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1832      * representation.</p>
1833      * <p>If this bitwise operation is used with values that are not integers or are too 
1834      * large to fit in a 32-bit integer representation, it simply coerces the values to 
1835      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
1836      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
1837      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
1838      * yields a number in the appropriate range.</p>
1839      * @param n The number of bits to shift.
1840      * @return The shifted primitive instance.
1841      * @since 1.0
1842      * @javascript A re-compiler is expected to replace the instance invocation of this 
1843      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1844      * <pre>d <<= n & 0x3f</pre>
1845      * where <tt>d</tt> is the integer value of the current date instance of the 
1846      * invocation of this method.
1847      */
1848     public Number ashl(int n) {
1849         return var().ashl(n);
1850     }
1851 
1852     /**
1853      * <p>Assignment-with-shift-right operation, resembling that of JavaScript, moves all bits in the 
1854      * current primitive instance to the right by the number of places specified in the 
1855      * second operand (an integer between 0 and 31). Bits that are shifted off the right 
1856      * are lost. The bits filled in on the left depend on the sign bit of the original 
1857      * value, in order to preserve the sign of the result. If the current primitive 
1858      * instance is positive, the result has zeros placed in the high bits; if the current 
1859      * primitive instance is negative, the result has ones placed in the high bits.</p>
1860      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
1861      * remainder), shifting right two places is equivalent to integer division by 4, and 
1862      * so on.</p>
1863      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1864      * operation requires numeric operands that have integer values. It operate on the integer 
1865      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1866      * representation.</p>
1867      * <p>If this bitwise operation is used with values that are not integers or are too 
1868      * large to fit in a 32-bit integer representation, it simply coerces the values to 
1869      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
1870      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
1871      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
1872      * yields a number in the appropriate range.</p>
1873      * @param n The number of bits to shift.
1874      * @return The shifted primitive instance.
1875      * @since 1.0
1876      * @javascript A re-compiler is expected to replace the instance invocation of this 
1877      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1878      * <pre>d >>= n & 0x3f</pre>
1879      * where <tt>d</tt> is the integer value of the current date instance of the 
1880      * invocation of this method.
1881      */
1882     public Number ashr(int n) {
1883         return var().ashr(n);
1884     }
1885 
1886     /**
1887      * <p>Assignment-with-shift-right-unsigned operation, resembling that of JavaScript, moves all bits in 
1888      * the current date instance to the right by the number of places specified in the 
1889      * second operand (an integer between 0 and 31). Bits that are shifted off the right 
1890      * are lost. The result has zeros placed in the high bits.</p>
1891      * <p>This operation is just like {@link #shr(int)}, except that the bits shifted 
1892      * in on the left are always zero, regardless of the sign of the current date instance.</p>
1893      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
1894      * remainder), shifting right two places is equivalent to integer division by 4, and 
1895      * so on.</p>
1896      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1897      * operation requires numeric operands that have integer values. It operate on the integer 
1898      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1899      * representation.</p>
1900      * <p>If this bitwise operation is used with values that are not integers or are too 
1901      * large to fit in a 32-bit integer representation, it simply coerces the values to 
1902      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
1903      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
1904      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
1905      * yields a number in the appropriate range.</p>
1906      * @param n The number of bits to shift.
1907      * @return The shifted primitive instance.
1908      * @since 1.0
1909      * @javascript A re-compiler is expected to replace the instance invocation of this 
1910      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1911      * <pre>d >>>= n & 0x3f</pre>
1912      * where <tt>d</tt> is the integer value of the current date instance of the 
1913      * invocation of this method.
1914      */
1915     public Number ashru(int n) {
1916         return var().ashru(n);
1917     }
1918 
1919     /**
1920      * <p>Assignment-with-bitwise-AND operation, resembling that of JavaScript, performs a boolean AND 
1921      * operation on each bit of the integer arguments. A bit is set in the result only if 
1922      * the corresponding bit is set in both operands.</p>
1923      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1924      * operation requires numeric operands that have integer values. It operate on the integer 
1925      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1926      * representation.</p>
1927      * <p>If this bitwise operation is used with operands that are not integers or are too 
1928      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
1929      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
1930      * the 32nd.</p>
1931      * @param value A numeric value.
1932      * @return The bitwise-AND of the two operands.
1933      * @since 1.0
1934      * @javascript A re-compiler is expected to replace the instance invocation of this 
1935      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1936      * <pre>d &= (char)value</pre>
1937      * where <tt>d</tt> is the integer value of the current date instance of the 
1938      * invocation of this method.
1939      */
1940     public Number aand(Object value) {
1941         return var().aand(value);
1942     }
1943 
1944     /**
1945      * <p>Assignment-with-bitwise-OR operation, resembling that of JavaScript, performs a boolean OR operation 
1946      * on each bit of the integer arguments. A bit is set in the result if the corresponding 
1947      * bit is set in one or both of the operands.</p>
1948      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1949      * operation requires numeric operands that have integer values. It operate on the integer 
1950      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1951      * representation.</p>
1952      * <p>If this bitwise operation is used with operands that are not integers or are too 
1953      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
1954      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
1955      * the 32nd.</p>
1956      * @param value A numeric value.
1957      * @return The bitwise-OR of the two operands.
1958      * @since 1.0
1959      * @javascript A re-compiler is expected to replace the instance invocation of this 
1960      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1961      * <pre>d |= (char)value</pre>
1962      * where <tt>d</tt> is the integer value of the current date instance of the 
1963      * invocation of this method.
1964      */
1965     public Number aor(Object value) {
1966         return var().aor(value);
1967     }
1968 
1969     /**
1970      * <p>Assignment-with-bitwise-XOR operation, resembling that of JavaScript, performs a boolean exclusive 
1971      * OR operation on each bit of the integer arguments. Exclusive OR means that either 
1972      * operand one is <tt>true</tt> or operand two is <tt>true</tt>, but not both. A bit is 
1973      * set in this operation's result if a corresponding bit is set in one (but not both) 
1974      * of the two operands.</p>
1975      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
1976      * operation requires numeric operands that have integer values. It operate on the integer 
1977      * operands using a 32-bit integer representation instead of the equivalent floating-point 
1978      * representation.</p>
1979      * <p>If this bitwise operation is used with operands that are not integers or are too 
1980      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
1981      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
1982      * the 32nd.</p>
1983      * @param value A numeric value.
1984      * @return The bitwise-exclusive-OR of the two operands.
1985      * @since 1.0
1986      * @javascript A re-compiler is expected to replace the instance invocation of this 
1987      * method with the equivalent JavaScript expression as re-compiled from the Java expression:  
1988      * <pre>d ^= (char)value</pre>
1989      * where <tt>d</tt> is the integer value of the current date instance of the 
1990      * invocation of this method.
1991      */
1992     public Number axor(Object value) {
1993         return var().aand(value);
1994     }
1995 
1996     /**
1997      * <p>Logically evaluates the current date instance.</p>
1998      * @return The logical value of the current date instance.
1999      * @since 1.0
2000      * @javascript Re-compilers must ignore the instance invocation of this method, that is, 
2001      * replacing it with its current date instance.
2002      */
2003     public final boolean be() {
2004         return Js.be(this);
2005     }
2006 
2007     /**
2008      * <p>Performs unary negation, resembling the unary minus operator in JavaScript.</p>
2009      * <p>This operation converts a positive value to an equivalently negative value, and 
2010      * vice versa. If the operand is not a number, it attempts to convert it to one.</p>
2011      * @return The negation of the current date instance.
2012      * @since 1.0
2013      * @javascript Re-compilers must replace the instance invocation of this method with the 
2014      * JavaScript expression:
2015      * <pre>-d</pre>
2016      * where <tt>d</tt> is the current date instance of the invocation of this 
2017      * method.
2018      */
2019     public final Number neg() {
2020         return Js.neg(this);
2021     }
2022 
2023     /**
2024      * <p>Inverts the boolean value of the current date instance, resembling the logical 
2025      * NOT operator in JavaScript.</p>
2026      * <p>This operation converts the current date instance to a boolean value using 
2027      * the following rules if necessary before inverting the converted value.</p>
2028      * <ul>
2029      * <li>If a number is used where a boolean value is expected, the number is converted 
2030      * to <tt>true</tt> unless the number is 0 or NaN, which are converted to <tt>false</tt>.</li>
2031      * <li>If a string is used where a boolean value is expected, it is converted to <tt>true</tt> 
2032      * except for the empty string, which is converted to <tt>false</tt>.</li>
2033      * <li><tt>null</tt> and the undefined value convert to <tt>false</tt>, and any 
2034      * non-null object, array, or function converts to <tt>true</tt>.
2035      * </ul>
2036      * <p>You can convert any value <tt>x</tt> to its equivalent boolean value by applying 
2037      * this operation twice: <tt>Js.not(Js.not(x))</tt></p>
2038      * <p>Note that, this method is probably useful in emulation codes just for perfect 
2039      * re-compilations. However, in most cases you can use the logical NOT operator of the 
2040      * Java language like this:
2041      * <pre>!Js.be(var)</pre>
2042      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
2043      * JavaScript expression since the Java compilers generally used are free to compile 
2044      * the expression into any byte codes they think efficient, making it too hard for the 
2045      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
2046      * @return The inverted boolean value.
2047      * @since 1.0
2048      * @javascript Re-compilers must replace the instance invocation of this method with the 
2049      * JavaScript expression:
2050      * <pre>!d</pre>
2051      * where <tt>d</tt> is the current date instance of the invocation of this method.
2052      */
2053     public final boolean not() {
2054         return Js.not(this);
2055     }
2056 
2057     /**
2058      * <p>Bitwise-NOT operation, resembling that of JavaScript, operates by reversing all 
2059      * bits in the current date instance.</p>
2060      * <p>Because of the way signed integers are represented in JavaScript, applying this 
2061      * operation to a value is equivalent to changing its sign and subtracting 1.</p>
2062      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2063      * operation requires numeric operands that have integer values. It operate on the integer 
2064      * values using a 32-bit integer representation instead of the equivalent floating-point 
2065      * representation.</p>
2066      * <p>If this bitwise operation is used with the current date instance that are 
2067      * not integers or are too large to fit in a 32-bit integer representation, it simply 
2068      * coerces them to 32-bit integers by dropping any fractional part of the value or any 
2069      * bits beyond the 32nd.</p>
2070      * @return The bitwise-NOT of the current date instance.
2071      * @since 1.0
2072      * @javascript Re-compilers must replace the instance invocation of this method with the 
2073      * JavaScript expression:
2074      * <pre>~d</pre>
2075      * where <tt>d</tt> is the current date instance of the invocation of this method.
2076      */
2077     public final int bnot() {
2078         return Js.bnot(valueOf());
2079     }
2080 
2081     /**
2082      * <p>Multiplies the value of the current date instance with the operand, resembling 
2083      * the multiplication operator in JavaScript.</p>
2084      * <p>If used with non-numeric values, this operation attempts to convert them to 
2085      * numbers.</p>
2086      * @param other Any numeric value.
2087      * @return The product of the current date instance and the operand.
2088      * @since 1.0
2089      * @javascript Re-compilers must replace the instance invocation of this method with the 
2090      * JavaScript expression:
2091      * <pre>d * other</pre>
2092      * where <tt>d</tt> is the current date instance of the invocation of this method.
2093      */
2094     public final Number mul(Object other) {
2095         return Js.mul(this, other);
2096     }
2097 
2098     /**
2099      * <p>Divides the value of the current date instance by the operand, resembling the 
2100      * division operator in JavaScript.</p>
2101      * <p>Used with non-numeric values, this operation attempts to convert them to 
2102      * numbers. If you are used to programming languages that distinguish between integer 
2103      * and floating-point numbers, you might expect to get an integer result when you 
2104      * divide one integer by another. In JavaScript, however, all numbers are floating-point, 
2105      * so all division operations have floating-point results. Division by zero yields positive 
2106      * or negative infinity, while <tt>0/0</tt> evaluates to <tt>NaN</tt>.</p>
2107      * @param other Any numeric value.
2108      * @return The quotient of the current date instance and the operand.
2109      * @since 1.0
2110      * @javascript Re-compilers must replace the instance invocation of this method with the 
2111      * JavaScript expression:
2112      * <pre>d / other</pre>
2113      * where <tt>d</tt> is the current date instance of the invocation of this method.
2114      */
2115     public final Number div(Object other) {
2116         return Js.div(this, other);
2117     }
2118 
2119     /**
2120      * <p>Computes the value of the current date instance modulo the operand, resembling 
2121      * the modulo operator in JavaScript.</p>
2122      * <p>The operation returns the remainder when the current date instance is divided 
2123      * by the operand a certain number of times. If used with non-numeric values, the 
2124      * operation attempts to convert them to numbers. The sign of the result is the same 
2125      * as the sign of the current date instance.</p>
2126      * <p>This operation is typically used with integer values, it also works for 
2127      * floating-point values.</p>
2128      * @param other Any numeric value.
2129      * @return The remainder.
2130      * @since 1.0
2131      * @javascript Re-compilers must replace the instance invocation of this method with the 
2132      * JavaScript expression:
2133      * <pre>d % other</pre>
2134      * where <tt>d</tt> is the current date instance of the invocation of this method.
2135      */
2136     public final Number mod(Object other) {
2137         return Js.mod(this, other);
2138     }
2139 
2140     /**
2141      * <p>Subtracts the operand from the value of the current date instance, resembling 
2142      * the subtraction operator in JavaScript.</p>
2143      * <p>If used with non-numeric values, this operation attempts to convert them to 
2144      * numbers.</p>
2145      * @param other Any numeric value.
2146      * @return The difference between the current date instance and the operand.
2147      * @since 1.0
2148      * @javascript Re-compilers must replace the instance invocation of this method with the 
2149      * JavaScript expression:
2150      * <pre>d - other</pre>
2151      * where <tt>d</tt> is the current date instance of the invocation of this method.
2152      */
2153     public final Number sub(Object other) {
2154         return Js.sub(this, other);
2155     }
2156 
2157     /**
2158      * <p>Adds the current date instance to a numeric operand or concatenates it with 
2159      * a string operand, resembling the addition operator in JavaScript.</p>
2160      * <p>If one value is a string, the other is converted to a string, and the two 
2161      * strings are then concatenated. Object operands are converted to numbers or strings 
2162      * that can be added or concatenated. The conversion is performed by {@link Js#valueOf(Object)}  
2163      * method and/or the {@link Js#toString(Object)} method on the object.</p>
2164      * @param other A value or object.
2165      * @return The sum or concatenation of the values.
2166      * @since 1.0
2167      * @javascript Re-compilers must replace the instance invocation of this method with the 
2168      * JavaScript expression:
2169      * <pre>d + other</pre>
2170      * where <tt>d</tt> is the current date instance of the invocation of this method.
2171      */
2172     public Object add(Object other) {
2173         return Js.add(this, other);
2174     }
2175 
2176     /**
2177      * <p>Adds the current date instance to a numeric operand or concatenates it with 
2178      * a string operand, resembling the addition operator in JavaScript.</p>
2179      * <p>If one value is a string, the other is converted to a string, and the two 
2180      * strings are then concatenated. Object operands are converted to numbers or strings 
2181      * that can be added or concatenated. The conversion is performed by {@link Js#valueOf(Object)}  
2182      * method and/or the {@link Js#toString(Object)} method on the object.</p>
2183      * @param other A value or object.
2184      * @return The sum or concatenation of the values.
2185      * @since 1.0
2186      * @javascript Re-compilers must replace the instance invocation of this method with the 
2187      * JavaScript expression:
2188      * <pre>d + other</pre>
2189      * where <tt>d</tt> is the current date instance of the invocation of this method.
2190      */
2191     public final String add(String other) {
2192         return Js.add(this, other);
2193     }
2194 
2195     /**
2196      * <p>Adds the current date instance to a numeric operand or concatenates it with 
2197      * a string operand, resembling the addition operator in JavaScript.</p>
2198      * <p>If one value is a string, the other is converted to a string, and the two 
2199      * strings are then concatenated. Object operands are converted to numbers or strings 
2200      * that can be added or concatenated. The conversion is performed by {@link Js#valueOf(Object)}  
2201      * method and/or the {@link Js#toString(Object)} method on the object.</p>
2202      * @param other A value or object.
2203      * @return The sum or concatenation of the values.
2204      * @since 1.0
2205      * @javascript Re-compilers must replace the instance invocation of this method with the 
2206      * JavaScript expression:
2207      * <pre>d + other</pre>
2208      * where <tt>d</tt> is the current date instance of the invocation of this method.
2209      */
2210     public final String add(Value<String> other) {
2211         return Js.add(this, other.var());
2212     }
2213 
2214     /**
2215      * <p>Less-than operation, resembling that of JavaScript, evaluates to <tt>true</tt> if 
2216      * the current date instance is less than the second operand; otherwise it 
2217      * evaluates to <tt>false</tt>.</p>
2218      * <p>The operands of this operation may be of any type. Comparison can be performed 
2219      * only on numbers and strings, however, so operands that are not numbers or strings 
2220      * are converted. Comparison and conversion occur as follows:</p>
2221      * <ul>
2222      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2223      * numerically.</li>
2224      * <li>If both operands are strings or convert to strings, they are compared as 
2225      * strings.</li>
2226      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2227      * the operation attempts to convert the string to a number and performs a numerical 
2228      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2229      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2230      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2231      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2232      * the numerical conversion. This means, for example, that Date objects are compared 
2233      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2234      * than the other.</li>
2235      * <li>If the operands of the comparison operations cannot both be successfully converted 
2236      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2237      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2238      * yields <tt>false</tt>.</li>
2239      * </ul>
2240      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2241      * basis using the numerical value of each character from the Unicode encoding. Although 
2242      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2243      * different sequences of characters, the JavaScript comparison operations do not 
2244      * detect these encoding differences; they assume that all strings are expressed in 
2245      * normalized form. Note in particular that string comparison is case-sensitive, and 
2246      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2247      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2248      * not expect it.</p>
2249      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2250      * method, which also takes locale-specific definitions of alphabetical order into account. 
2251      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2252      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2253      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2254      * equality or identity operations for determining whether two values are "equal." 
2255      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2256      * and the greater-than-or-equal operator is defined as "not less than". The one 
2257      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2258      * all comparison operations return <tt>false</tt>.</p>
2259      * @param other A value or object.
2260      * @return <tt>true</tt> if the current date instance is less than the second 
2261      * operand; otherwise <tt>false</tt>.
2262      * @since 1.0
2263      * @javascript Re-compilers must replace the instance invocation of this method with the 
2264      * JavaScript expression:
2265      * <pre>d < other</pre>
2266      * where <tt>d</tt> is the current date instance of the invocation of this method.
2267      */
2268     public final boolean lt(Object other) {
2269         return Js.lt(valueOf(), other);
2270     }
2271 
2272     /**
2273      * <p>Greater-than operation, resembling that of JavaScript, evaluates to <tt>true</tt> if 
2274      * the current date instance is greater than the second operand; otherwise it 
2275      * evaluates to <tt>false</tt>.</p>
2276      * <p>The operands of this operation may be of any type. Comparison can be performed 
2277      * only on numbers and strings, however, so operands that are not numbers or strings 
2278      * are converted. Comparison and conversion occur as follows:</p>
2279      * <ul>
2280      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2281      * numerically.</li>
2282      * <li>If both operands are strings or convert to strings, they are compared as 
2283      * strings.</li>
2284      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2285      * the operation attempts to convert the string to a number and performs a numerical 
2286      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2287      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2288      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2289      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2290      * the numerical conversion. This means, for example, that Date objects are compared 
2291      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2292      * than the other.</li>
2293      * <li>If the operands of the comparison operations cannot both be successfully converted 
2294      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2295      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2296      * yields <tt>false</tt>.</li>
2297      * </ul>
2298      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2299      * basis using the numerical value of each character from the Unicode encoding. Although 
2300      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2301      * different sequences of characters, the JavaScript comparison operations do not 
2302      * detect these encoding differences; they assume that all strings are expressed in 
2303      * normalized form. Note in particular that string comparison is case-sensitive, and 
2304      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2305      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2306      * not expect it.</p>
2307      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2308      * method, which also takes locale-specific definitions of alphabetical order into account. 
2309      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2310      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2311      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2312      * equality or identity operations for determining whether two values are "equal." 
2313      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2314      * and the greater-than-or-equal operator is defined as "not less than". The one 
2315      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2316      * all comparison operations return <tt>false</tt>.</p>
2317      * @param other A value or object.
2318      * @return <tt>true</tt> if the current date instance is greater than the second 
2319      * operand; otherwise <tt>false</tt>.
2320      * @since 1.0
2321      * @javascript Re-compilers must replace the instance invocation of this method with the 
2322      * JavaScript expression:
2323      * <pre>p > other</pre>
2324      * where <tt>p</tt> is the current date instance of the invocation of this method.
2325      */
2326     public final boolean gt(Object other) {
2327         return Js.gt(valueOf(), other);
2328     }
2329 
2330     /**
2331      * <p>Less-than-or-equal operation, resembling that of JavaScript, evaluates to 
2332      * <tt>true</tt> if the current date instance is less than or equal to the second 
2333      * operand; otherwise it evaluates to <tt>false</tt>.</p>
2334      * <p>The operands of this operation may be of any type. Comparison can be performed 
2335      * only on numbers and strings, however, so operands that are not numbers or strings 
2336      * are converted. Comparison and conversion occur as follows:</p>
2337      * <ul>
2338      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2339      * numerically.</li>
2340      * <li>If both operands are strings or convert to strings, they are compared as 
2341      * strings.</li>
2342      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2343      * the operation attempts to convert the string to a number and performs a numerical 
2344      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2345      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2346      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2347      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2348      * the numerical conversion. This means, for example, that Date objects are compared 
2349      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2350      * than the other.</li>
2351      * <li>If the operands of the comparison operations cannot both be successfully converted 
2352      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2353      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2354      * yields <tt>false</tt>.</li>
2355      * </ul>
2356      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2357      * basis using the numerical value of each character from the Unicode encoding. Although 
2358      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2359      * different sequences of characters, the JavaScript comparison operations do not 
2360      * detect these encoding differences; they assume that all strings are expressed in 
2361      * normalized form. Note in particular that string comparison is case-sensitive, and 
2362      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2363      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2364      * not expect it.</p>
2365      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2366      * method, which also takes locale-specific definitions of alphabetical order into account. 
2367      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2368      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2369      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2370      * equality or identity operations for determining whether two values are "equal." 
2371      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2372      * and the greater-than-or-equal operator is defined as "not less than". The one 
2373      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2374      * all comparison operations return <tt>false</tt>.</p>
2375      * @param other A value or object.
2376      * @return <tt>true</tt> if the current date instance is less than or equal to 
2377      * the second operand; otherwise <tt>false</tt>.
2378      * @since 1.0
2379      * @javascript Re-compilers must replace the instance invocation of this method with the 
2380      * JavaScript expression:
2381      * <pre>p <= other</pre>
2382      * where <tt>p</tt> is the current date instance of the invocation of this method.
2383      */
2384     public final boolean lte(Object other) {
2385         return Js.lte(valueOf(), other);
2386     }
2387 
2388     /**
2389      * <p>Greater-than-or-equal operation, resembling that of JavaScript, evaluates to 
2390      * <tt>true</tt> if the current date instance is greater than or equal to the 
2391      * second operand; otherwise it evaluates to <tt>false</tt>.</p>
2392      * <p>The operands of this operation may be of any type. Comparison can be performed 
2393      * only on numbers and strings, however, so operands that are not numbers or strings 
2394      * are converted. Comparison and conversion occur as follows:</p>
2395      * <ul>
2396      * <li>If both operands are numbers, or if both convert to numbers, they are compared 
2397      * numerically.</li>
2398      * <li>If both operands are strings or convert to strings, they are compared as 
2399      * strings.</li>
2400      * <li>If one operand is or converts to a string, and one is or converts to a number, 
2401      * the operation attempts to convert the string to a number and performs a numerical 
2402      * comparison. If the string does not represent a number, it converts to <tt>NaN</tt>, 
2403      * and the comparison is <tt>false</tt>. In JavaScript 1.1, the string-to-number 
2404      * conversion causes an error instead of yielding <tt>NaN</tt>.</li>
2405      * <li>If an object can be converted to either a number or a string, JavaScript performs 
2406      * the numerical conversion. This means, for example, that Date objects are compared 
2407      * numerically, and it is meaningful to compare two dates to see whether one is earlier 
2408      * than the other.</li>
2409      * <li>If the operands of the comparison operations cannot both be successfully converted 
2410      * to numbers or to strings, these operations always return <tt>false</tt>.</li>
2411      * <li>If either operand is or converts to <tt>NaN</tt>, the comparison operation always 
2412      * yields <tt>false</tt>.</li>
2413      * </ul>
2414      * <p>Keep in mind that string comparison is done on a strict character-by-character 
2415      * basis using the numerical value of each character from the Unicode encoding. Although 
2416      * in some cases the Unicode standard allows equivalent strings to be encoded using 
2417      * different sequences of characters, the JavaScript comparison operations do not 
2418      * detect these encoding differences; they assume that all strings are expressed in 
2419      * normalized form. Note in particular that string comparison is case-sensitive, and 
2420      * in the Unicode encoding (at least for the ASCII subset), all capital letters are 
2421      * "less than" all lowercase letters. This rule can cause confusing results if you do 
2422      * not expect it.</p>
2423      * <p>For a more robust string-comparison algorithm, see the {@link StringLike#localeCompare(Object)} 
2424      * method, which also takes locale-specific definitions of alphabetical order into account. 
2425      * For case-insensitive comparisons, you must first convert the strings to all lowercase or 
2426      * all uppercase using {@link StringLike#toLowerCase()} or {@link StringLike#toUpperCase()}.</p>
2427      * <p>The less-than-or-equal and greater-than-or-equal operations do not rely on the 
2428      * equality or identity operations for determining whether two values are "equal." 
2429      * Instead, the less-than-or-equal operator is simply defined as "not greater than", 
2430      * and the greater-than-or-equal operator is defined as "not less than". The one 
2431      * exception occurs when either operand is (or converts to) <tt>NaN</tt>, in which case 
2432      * all comparison operations return <tt>false</tt>.</p>
2433      * @param other A value or object.
2434      * @return <tt>true</tt> if the current date instance is greater than or equal to 
2435      * the second operand; otherwise <tt>false</tt>.
2436      * @since 1.0
2437      * @javascript Re-compilers must replace the instance invocation of this method with the 
2438      * JavaScript expression:
2439      * <pre>p >= other</pre>
2440      * where <tt>p</tt> is the current date instance of the invocation of this method.
2441      */
2442     public final boolean gte(Object other) {
2443         return Js.gte(valueOf(), other);
2444     }
2445 
2446     /**
2447      * <p>Checks if the current date instance is an instance of the second operand, 
2448      * resembling the <tt>instanceof</tt> operator in JavaScript.</p>
2449      * <p>This operation expects the first operand be an object and the second be a class 
2450      * of objects. In JavaScript, classes of objects are defined by the constructor function 
2451      * that initializes them.</p>
2452      * @param other A constructor function.
2453      * @return <tt>true</tt> if the current date instance is an instance of the second 
2454      * operand; <tt>false</tt>, otherwise;
2455      * @since 1.0
2456      * @javascript Re-compilers must replace the instance invocation of this method with the 
2457      * JavaScript expression:
2458      * <pre>p instanceof other</pre>
2459      * where <tt>p</tt> is the current date instance of the invocation of this method.
2460      */
2461     public final boolean instanceOf(Object other) {
2462         return Js.instanceOf(this, other);
2463     }
2464 
2465     /**
2466      * <p>Checks whether the two operands are "equal" using a more relaxed definition of 
2467      * sameness that allows type conversions, resembling the equality operator in 
2468      * JavaScript.</p>
2469      * <p>The equality and identity operations check whether two values are the same, using 
2470      * two different definitions of sameness. Both operations accept operands of any type, 
2471      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2472      * if they are different. The identity operation checks whether its two operands are 
2473      * "identical" using a strict definition of sameness. The equality operation checks 
2474      * whether its two operands are "equal" using a more relaxed definition of sameness 
2475      * that allows type conversions.</p>
2476      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2477      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2478      * assignment, equality, and identity operations, and be careful to use the correct one 
2479      * when coding! Although it is tempting to call all three operations "equals," it may 
2480      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2481      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2482      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2483      * case, two separate values are involved, and the equality and identity operations 
2484      * check that these two values are identical. This means that two variables are equal 
2485      * or identical only if they contain the same value. For example, two strings are equal 
2486      * only if they each contain exactly the same characters.</p>
2487      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2488      * means that two variables are equal only if they refer to the same object. Two 
2489      * separate arrays are never equal or identical, even if they contain equal or identical 
2490      * elements. Two variables that contain references to objects, arrays, or functions are 
2491      * equal only if they refer to the same object, array, or function. If you want to test 
2492      * that two distinct objects contain the same properties or that two distinct arrays 
2493      * contain the same elements, you'll have to check the properties or elements individually 
2494      * for equality or identity. And, if any of the properties or elements are themselves 
2495      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2496      * <p>The following rules determine whether two values are equal according to the 
2497      * equality operation:
2498      * <ul>
2499      * <li>If the two values have the same type, test them for identity. If the values are 
2500      * identical, they are equal; if they are not identical, they are not equal.</li>
2501      * <li>If the two values do not have the same type, they may still be equal. Use the 
2502      * following rules and type conversions to check for equality:</li>
2503      * <ul>
2504      * <li>If one value is null and the other is undefined, they are equal.</li>
2505      * <li>If one value is a number and the other is a string, convert the string to a 
2506      * number and try the comparison again, using the converted value.</li>
2507      * <li>If either value is <tt>true</tt>, convert it to 1 and try the comparison 
2508      * again. If either value is <tt>false</tt>, convert it to 0 and try the comparison 
2509      * again.</li>
2510      * <li>If one value is an object and the other is a number or string, convert the 
2511      * object to a primitive and try the comparison again. An object is converted to a 
2512      * primitive value by either its <tt>toString()</tt> method or its <tt>valueOf()</tt> 
2513      * method. The built-in classes of core JavaScript attempt <tt>valueOf()</tt> 
2514      * conversion before <tt>toString()</tt> conversion, except for the Date class, 
2515      * which performs <tt>toString()</tt> conversion. Objects that are not part of core 
2516      * JavaScript may convert themselves to primitive values in an implementation-defined 
2517      * way.</li>
2518      * <li>Any other combinations of values are not equal.</li>
2519      * </ul>
2520      * </ul>
2521      * @param other Any value or object.
2522      * @return <tt>true</tt> if the first operand equals the second; <tt>false</tt>, 
2523      * otherwise;
2524      * @since 1.0
2525      * @javascript Re-compilers must replace the instance invocation of this method with the 
2526      * JavaScript expression:
2527      * <pre>p == other</pre>
2528      * where <tt>p</tt> is the current date instance of the invocation of this method.
2529      */
2530     public final boolean eq(Object other) {
2531         return Js.eq(this, other);
2532     }
2533 
2534     /**
2535      * <p>Checks whether the two operands are "identical" using a strict definition of 
2536      * sameness, resembling the identity operator in JavaScript.</p>
2537      * <p>The equality and identity operations check whether two values are the same, using 
2538      * two different definitions of sameness. Both operations accept operands of any type, 
2539      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2540      * if they are different. The identity operation checks whether its two operands are 
2541      * "identical" using a strict definition of sameness. The equality operation checks 
2542      * whether its two operands are "equal" using a more relaxed definition of sameness 
2543      * that allows type conversions.</p>
2544      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2545      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2546      * assignment, equality, and identity operations, and be careful to use the correct one 
2547      * when coding! Although it is tempting to call all three operations "equals," it may 
2548      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2549      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2550      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2551      * case, two separate values are involved, and the equality and identity operations 
2552      * check that these two values are identical. This means that two variables are equal 
2553      * or identical only if they contain the same value. For example, two strings are equal 
2554      * only if they each contain exactly the same characters.</p>
2555      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2556      * means that two variables are equal only if they refer to the same object. Two 
2557      * separate arrays are never equal or identical, even if they contain equal or identical 
2558      * elements. Two variables that contain references to objects, arrays, or functions are 
2559      * equal only if they refer to the same object, array, or function. If you want to test 
2560      * that two distinct objects contain the same properties or that two distinct arrays 
2561      * contain the same elements, you'll have to check the properties or elements individually 
2562      * for equality or identity. And, if any of the properties or elements are themselves 
2563      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2564      * <p>The following rules determine whether two values are identical according to the identity operation:
2565      * <ul>
2566      * <li>If the two values have different types, they are not identical.</li>
2567      * <li>If both values are numbers and have the same value, they are identical, unless 
2568      * either or both values are <tt>NaN</tt>, in which case they are not identical. 
2569      * The <tt>NaN</tt> value is never identical to any other value, including itself! 
2570      * To check whether a value is <tt>NaN</tt>, use the global {@link Js#isNaN(Object)} 
2571      * function.</li>
2572      * <li>If both values are strings and contain exactly the same characters in the same 
2573      * positions, they are identical. If the strings differ in length or content, they are 
2574      * not identical. Note that in some cases, the Unicode standard allows more than one 
2575      * way to encode the same string. For efficiency, however, JavaScript's string 
2576      * comparison compares strictly on a character-by-character basis, and it assumes that 
2577      * all strings have been converted to a "normalized form" before they are compared. 
2578      * See the {@link StringLike#localeCompare(Object)} for another way to compare strings.</li>
2579      * <li>If both values are the boolean value <tt>true</tt> or both are the boolean 
2580      * value <tt>false</tt>, they are identical.</li>
2581      * <li>If both values refer to the same object, array, or function, they are identical. 
2582      * If they refer to different objects (or arrays or functions) they are not identical, 
2583      * even if both objects have identical properties or both arrays have identical elements.</li>
2584      * <li>If both values are null or both values are undefined, they are identical.</li>
2585      * </ul>
2586      * @param other Any value or object.
2587      * @return <tt>true</tt> if the first operand is identical to the second; 
2588      * <tt>false</tt>, otherwise;
2589      * @since 1.0
2590      * @javascript Re-compilers must replace the instance invocation of this method with the 
2591      * JavaScript expression:
2592      * <pre>p === other</pre>
2593      * where <tt>p</tt> is the current date instance of the invocation of this method.
2594      */
2595     public final boolean eqs(Object other) {
2596         return Js.eqs(this, other);
2597     }
2598 
2599     /**
2600      * <p>Checks whether the two operands are not "equal" using a more relaxed definition of 
2601      * sameness that allows type conversions, resembling the equality operator in 
2602      * JavaScript.</p>
2603      * <p>The equality and identity operations check whether two values are the same, using 
2604      * two different definitions of sameness. Both operations accept operands of any type, 
2605      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2606      * if they are different. The identity operation checks whether its two operands are 
2607      * "identical" using a strict definition of sameness. The equality operation checks 
2608      * whether its two operands are "equal" using a more relaxed definition of sameness 
2609      * that allows type conversions.</p>
2610      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2611      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2612      * assignment, equality, and identity operations, and be careful to use the correct one 
2613      * when coding! Although it is tempting to call all three operations "equals," it may 
2614      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2615      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2616      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2617      * case, two separate values are involved, and the equality and identity operations 
2618      * check that these two values are identical. This means that two variables are equal 
2619      * or identical only if they contain the same value. For example, two strings are equal 
2620      * only if they each contain exactly the same characters.</p>
2621      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2622      * means that two variables are equal only if they refer to the same object. Two 
2623      * separate arrays are never equal or identical, even if they contain equal or identical 
2624      * elements. Two variables that contain references to objects, arrays, or functions are 
2625      * equal only if they refer to the same object, array, or function. If you want to test 
2626      * that two distinct objects contain the same properties or that two distinct arrays 
2627      * contain the same elements, you'll have to check the properties or elements individually 
2628      * for equality or identity. And, if any of the properties or elements are themselves 
2629      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2630      * <p>The following rules determine whether two values are equal according to the 
2631      * equality operation:
2632      * <ul>
2633      * <li>If the two values have the same type, test them for identity. If the values are 
2634      * identical, they are equal; if they are not identical, they are not equal.</li>
2635      * <li>If the two values do not have the same type, they may still be equal. Use the 
2636      * following rules and type conversions to check for equality:</li>
2637      * <ul>
2638      * <li>If one value is null and the other is undefined, they are equal.</li>
2639      * <li>If one value is a number and the other is a string, convert the string to a 
2640      * number and try the comparison again, using the converted value.</li>
2641      * <li>If either value is <tt>true</tt>, convert it to 1 and try the comparison 
2642      * again. If either value is <tt>false</tt>, convert it to 0 and try the comparison 
2643      * again.</li>
2644      * <li>If one value is an object and the other is a number or string, convert the 
2645      * object to a primitive and try the comparison again. An object is converted to a 
2646      * primitive value by either its <tt>toString()</tt> method or its <tt>valueOf()</tt> 
2647      * method. The built-in classes of core JavaScript attempt <tt>valueOf()</tt> 
2648      * conversion before <tt>toString()</tt> conversion, except for the Date class, 
2649      * which performs <tt>toString()</tt> conversion. Objects that are not part of core 
2650      * JavaScript may convert themselves to primitive values in an implementation-defined 
2651      * way.</li>
2652      * <li>Any other combinations of values are not equal.</li>
2653      * </ul>
2654      * </ul>
2655      * @param other Any value or object.
2656      * @return <tt>false</tt> if the first operand equals the second; <tt>true</tt>, 
2657      * otherwise;
2658      * @since 1.0
2659      * @javascript Re-compilers must replace the instance invocation of this method with the 
2660      * JavaScript expression:
2661      * <pre>p != other</pre>
2662      * where <tt>p</tt> is the current date instance of the invocation of this method.
2663      */
2664     public final boolean neq(Object other) {
2665         return Js.neq(this, other);
2666     }
2667 
2668     /**
2669      * <p>Checks whether the two operands are not "identical" using a strict definition of 
2670      * sameness, resembling the identity operator in JavaScript.</p>
2671      * <p>The equality and identity operations check whether two values are the same, using 
2672      * two different definitions of sameness. Both operations accept operands of any type, 
2673      * and both return <tt>true</tt> if their operands are the same and <tt>false</tt> 
2674      * if they are different. The identity operation checks whether its two operands are 
2675      * "identical" using a strict definition of sameness. The equality operation checks 
2676      * whether its two operands are "equal" using a more relaxed definition of sameness 
2677      * that allows type conversions.</p>
2678      * <p>The identity operation is standardized by ECMAScript v3 and implemented in 
2679      * JavaScript 1.3 and later. Be sure you understand the differences between the 
2680      * assignment, equality, and identity operations, and be careful to use the correct one 
2681      * when coding! Although it is tempting to call all three operations "equals," it may 
2682      * help to reduce confusion if you read "gets or is assigned" for assignment operation, 
2683      * "is equal to" for equality operation, and "is identical to" for identity operation.</p>
2684      * <p>In JavaScript, numbers, strings, and boolean values are compared by value. In this 
2685      * case, two separate values are involved, and the equality and identity operations 
2686      * check that these two values are identical. This means that two variables are equal 
2687      * or identical only if they contain the same value. For example, two strings are equal 
2688      * only if they each contain exactly the same characters.</p>
2689      * <p>On the other hand, objects, arrays, and functions are compared by reference. This 
2690      * means that two variables are equal only if they refer to the same object. Two 
2691      * separate arrays are never equal or identical, even if they contain equal or identical 
2692      * elements. Two variables that contain references to objects, arrays, or functions are 
2693      * equal only if they refer to the same object, array, or function. If you want to test 
2694      * that two distinct objects contain the same properties or that two distinct arrays 
2695      * contain the same elements, you'll have to check the properties or elements individually 
2696      * for equality or identity. And, if any of the properties or elements are themselves 
2697      * objects or arrays, you'll have to decide how deep you want the comparison to go.</p>
2698      * <p>The following rules determine whether two values are identical according to the identity operation:
2699      * <ul>
2700      * <li>If the two values have different types, they are not identical.</li>
2701      * <li>If both values are numbers and have the same value, they are identical, unless 
2702      * either or both values are <tt>NaN</tt>, in which case they are not identical. 
2703      * The <tt>NaN</tt> value is never identical to any other value, including itself! 
2704      * To check whether a value is <tt>NaN</tt>, use the global {@link Js#isNaN(Object)} 
2705      * function.</li>
2706      * <li>If both values are strings and contain exactly the same characters in the same 
2707      * positions, they are identical. If the strings differ in length or content, they are 
2708      * not identical. Note that in some cases, the Unicode standard allows more than one 
2709      * way to encode the same string. For efficiency, however, JavaScript's string 
2710      * comparison compares strictly on a character-by-character basis, and it assumes that 
2711      * all strings have been converted to a "normalized form" before they are compared. 
2712      * See the {@link StringLike#localeCompare(Object)} for another way to compare strings.</li>
2713      * <li>If both values are the boolean value <tt>true</tt> or both are the boolean 
2714      * value <tt>false</tt>, they are identical.</li>
2715      * <li>If both values refer to the same object, array, or function, they are identical. 
2716      * If they refer to different objects (or arrays or functions) they are not identical, 
2717      * even if both objects have identical properties or both arrays have identical elements.</li>
2718      * <li>If both values are null or both values are undefined, they are identical.</li>
2719      * </ul>
2720      * @param other Any value or object.
2721      * @return <tt>false</tt> if the first operand is identical to the second; 
2722      * <tt>true</tt>, otherwise;
2723      * @since 1.0
2724      * @javascript Re-compilers must replace the instance invocation of this method with the 
2725      * JavaScript expression:
2726      * <pre>p !== other</pre>
2727      * where <tt>p</tt> is the current date instance of the invocation of this method.
2728      */
2729     public final boolean neqs(Object other) {
2730         return Js.neqs(this, other);
2731     }
2732 
2733     /**
2734      * <p>Bitwise-AND operation, resembling that of JavaScript, performs a boolean AND 
2735      * operation on each bit of the integer arguments. A bit is set in the result only if 
2736      * the corresponding bit is set in both operands.</p>
2737      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2738      * operation requires numeric operands that have integer values. It operate on the integer 
2739      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2740      * representation.</p>
2741      * <p>If this bitwise operation is used with operands that are not integers or are too 
2742      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2743      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2744      * the 32nd.</p>
2745      * @param other A numeric value.
2746      * @return The bitwise-AND of the two operands.
2747      * @since 1.0
2748      * @javascript Re-compilers must replace the instance invocation of this method with the 
2749      * JavaScript expression:
2750      * <pre>p & other</pre>
2751      * where <tt>p</tt> is the current date instance of the invocation of this method.
2752      */
2753     public final int band(Object other) {
2754         return Js.band(valueOf(), other);
2755     }
2756 
2757     /**
2758      * <p>Bitwise-OR operation, resembling that of JavaScript, performs a boolean OR operation 
2759      * on each bit of the integer arguments. A bit is set in the result if the corresponding 
2760      * bit is set in one or both of the operands.</p>
2761      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2762      * operation requires numeric operands that have integer values. It operate on the integer 
2763      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2764      * representation.</p>
2765      * <p>If this bitwise operation is used with operands that are not integers or are too 
2766      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2767      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2768      * the 32nd.</p>
2769      * @param other A numeric value.
2770      * @return The bitwise-OR of the two operands.
2771      * @since 1.0
2772      * @javascript Re-compilers must replace the instance invocation of this method with the 
2773      * JavaScript expression:
2774      * <pre>p | other</pre>
2775      * where <tt>p</tt> is the current date instance of the invocation of this method.
2776      */
2777     public final int bor(Object other) {
2778         return Js.bor(valueOf(), other);
2779     }
2780 
2781     /**
2782      * <p>Bitwise-XOR operation, resembling that of JavaScript, performs a boolean exclusive 
2783      * OR operation on each bit of the integer arguments. Exclusive OR means that either 
2784      * operand one is <tt>true</tt> or operand two is <tt>true</tt>, but not both. A bit is 
2785      * set in this operation's result if a corresponding bit is set in one (but not both) 
2786      * of the two operands.</p>
2787      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2788      * operation requires numeric operands that have integer values. It operate on the integer 
2789      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2790      * representation.</p>
2791      * <p>If this bitwise operation is used with operands that are not integers or are too 
2792      * large to fit in a 32-bit integer representation, it simply coerces the operands to 
2793      * 32-bit integers by dropping any fractional part of the operand or any bits beyond 
2794      * the 32nd.</p>
2795      * @param other A numeric value.
2796      * @return The bitwise-exclusive-OR of the two operands.
2797      * @since 1.0
2798      * @javascript Re-compilers must replace the instance invocation of this method with the 
2799      * JavaScript expression:
2800      * <pre>p ^ other</pre>
2801      * where <tt>p</tt> is the current date instance of the invocation of this method.
2802      */
2803     public final int xor(Object other) {
2804         return Js.xor(valueOf(), other);
2805     }
2806 
2807     /**
2808      * <p>Shift-left operation, resembling that of JavaScript, moves all bits in the 
2809      * current primitive instance to the left by the number of places specified in the 
2810      * second operand, which should be an integer between 0 and 31.</p>
2811      * <p>A zero is used for the new first bit, and the value of the 32nd bit is lost. 
2812      * Shifting a value left by one position is equivalent to multiplying by 2, shifting 
2813      * two positions is equivalent to multiplying by 4, etc.</p>
2814      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2815      * operation requires numeric operands that have integer values. It operate on the integer 
2816      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2817      * representation.</p>
2818      * <p>If this bitwise operation is used with values that are not integers or are too 
2819      * large to fit in a 32-bit integer representation, it simply coerces the values to 
2820      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
2821      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
2822      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2823      * yields a number in the appropriate range.</p>
2824      * @param n The number of bits to shift.
2825      * @return The shifted integer number.
2826      * @since 1.0
2827      * @javascript Re-compilers must replace the instance invocation of this method with the 
2828      * JavaScript expression:
2829      * <pre>p << n</pre>
2830      * where <tt>p</tt> is the current date instance of the invocation of this method.
2831      */
2832     public final int shl(int n) {
2833         return Js.shl(valueOf(), n);
2834     }
2835 
2836     /**
2837      * <p>Shift-right operation, resembling that of JavaScript, moves all bits in the 
2838      * current primitive instance to the right by the number of places specified in the 
2839      * second operand (an integer between 0 and 31). Bits that are shifted off the right 
2840      * are lost. The bits filled in on the left depend on the sign bit of the original 
2841      * value, in order to preserve the sign of the result. If the current primitive 
2842      * instance is positive, the result has zeros placed in the high bits; if the current 
2843      * primitive instance is negative, the result has ones placed in the high bits.</p>
2844      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
2845      * remainder), shifting right two places is equivalent to integer division by 4, and 
2846      * so on.</p>
2847      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2848      * operation requires numeric operands that have integer values. It operate on the integer 
2849      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2850      * representation.</p>
2851      * <p>If this bitwise operation is used with values that are not integers or are too 
2852      * large to fit in a 32-bit integer representation, it simply coerces the values to 
2853      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
2854      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
2855      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2856      * yields a number in the appropriate range.</p>
2857      * @param n The number of bits to shift.
2858      * @return The shifted integer number.
2859      * @since 1.0
2860      * @javascript Re-compilers must replace the instance invocation of this method with the 
2861      * JavaScript expression:
2862      * <pre>p >> n</pre>
2863      * where <tt>p</tt> is the current date instance of the invocation of this method.
2864      */
2865     public final int shr(int n) {
2866         return Js.shr(valueOf(), n);
2867     }
2868 
2869     /**
2870      * <p>Shift-right-unsigned operation, resembling that of JavaScript, moves all bits in 
2871      * the current date instance to the right by the number of places specified in the 
2872      * second operand (an integer between 0 and 31). Bits that are shifted off the right 
2873      * are lost. The result has zeros placed in the high bits.</p>
2874      * <p>This operation is just like {@link #shr(int)}, except that the bits shifted 
2875      * in on the left are always zero, regardless of the sign of the current date instance.</p>
2876      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
2877      * remainder), shifting right two places is equivalent to integer division by 4, and 
2878      * so on.</p>
2879      * <p>Despite the fact that all numbers in JavaScript are floating-point numbers, the bitwise 
2880      * operation requires numeric operands that have integer values. It operate on the integer 
2881      * operands using a 32-bit integer representation instead of the equivalent floating-point 
2882      * representation.</p>
2883      * <p>If this bitwise operation is used with values that are not integers or are too 
2884      * large to fit in a 32-bit integer representation, it simply coerces the values to 
2885      * 32-bit integers by dropping any fractional part of the value or any bits beyond 
2886      * the 32nd. The shift operation requires a (right-side) operand between 0 and 31. After 
2887      * converting this operand to a 32-bit integer, it drops any bits beyond the 5th, which 
2888      * yields a number in the appropriate range.</p>
2889      * @param n The number of bits to shift.
2890      * @return The shifted integer number.
2891      * @since 1.0
2892      * @javascript Re-compilers must replace the instance invocation of this method with the 
2893      * JavaScript expression:
2894      * <pre>p >>> n</pre>
2895      * where <tt>p</tt> is the current date instance of the invocation of this method.
2896      */
2897     public final int shru(int n) {
2898         return Js.shru(valueOf(), n);
2899     }
2900 
2901     /**
2902      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
2903      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
2904      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
2905      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
2906      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
2907      * may or may not evaluate the right-side expression. The actual behavior of the operator 
2908      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
2909      * on its left. If the value of this expression can be converted to <tt>false</tt> 
2910      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
2911      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
2912      * its second operand, the expression on its right, and returns the value of that 
2913      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
2914      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
2915      * returning the unconverted value of the left-side expression.</p>
2916      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
2917      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
2918      * anonymously, returning the actual expression in the method overriding 
2919      * {@link Var#var()}.</p>
2920      * <p>Sometimes, this operation probably does not do what the programmers intended. 
2921      * To avoid problems, do not use expressions with side effects (assignments, increments, 
2922      * decrements, and function calls) for the second operand unless you are quite sure 
2923      * you know exactly what you are doing.</p>
2924      * <p>Despite the fairly confusing way that this operation actually works, it is 
2925      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
2926      * Although it does not actually return a boolean value, the value it returns can always 
2927      * be converted to a boolean value.</p>
2928      * <p>Note that, this method is probably useful in emulation codes just for perfect 
2929      * re-compilations. However, in most cases you can use the logical AND operator of the 
2930      * Java language like this:
2931      * <pre>Js.be(var) && Js.be(other)</pre>
2932      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
2933      * JavaScript expression since the Java compilers generally used are free to compile 
2934      * the expression into any byte codes they think efficient, making it too hard for the 
2935      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
2936      * @param other A value or object.
2937      * @return The logical AND of the two operands.
2938      * @since 1.0
2939      * @javascript Re-compilers must replace the instance invocation of this method with the 
2940      * JavaScript expression:
2941      * <pre>p && other</pre>
2942      * where <tt>p</tt> is the current date instance of the invocation of this method.
2943      */
2944     public final Object and(Object other) {
2945         return Js.and(this, other);
2946     }
2947 
2948     /**
2949      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
2950      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
2951      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
2952      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
2953      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
2954      * may or may not evaluate the right-side expression. The actual behavior of the operator 
2955      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
2956      * on its left. If the value of this expression can be converted to <tt>false</tt> 
2957      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
2958      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
2959      * its second operand, the expression on its right, and returns the value of that 
2960      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
2961      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
2962      * returning the unconverted value of the left-side expression.</p>
2963      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
2964      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
2965      * anonymously, returning the actual expression in the method overriding 
2966      * {@link Var#var()}.</p>
2967      * <p>Sometimes, this operation probably does not do what the programmers intended. 
2968      * To avoid problems, do not use expressions with side effects (assignments, increments, 
2969      * decrements, and function calls) for the second operand unless you are quite sure 
2970      * you know exactly what you are doing.</p>
2971      * <p>Despite the fairly confusing way that this operation actually works, it is 
2972      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
2973      * Although it does not actually return a boolean value, the value it returns can always 
2974      * be converted to a boolean value.</p>
2975      * <p>Note that, this method is probably useful in emulation codes just for perfect 
2976      * re-compilations. However, in most cases you can use the logical AND operator of the 
2977      * Java language like this:
2978      * <pre>Js.be(var) && Js.be(other)</pre>
2979      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
2980      * JavaScript expression since the Java compilers generally used are free to compile 
2981      * the expression into any byte codes they think efficient, making it too hard for the 
2982      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
2983      * @param other A value or object.
2984      * @return The logical AND of the two operands.
2985      * @since 1.0
2986      * @javascript Re-compilers must replace the instance invocation of this method with the 
2987      * JavaScript expression:
2988      * <pre>p && other</pre>
2989      * where <tt>p</tt> is the current date instance of the invocation of this method.
2990      */
2991     public final JsObject and(Var<? extends JsObject> other) {
2992         return Js.and(this, other);
2993     }
2994 
2995     /**
2996      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
2997      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
2998      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
2999      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3000      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3001      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3002      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3003      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3004      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3005      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3006      * its second operand, the expression on its right, and returns the value of that 
3007      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3008      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3009      * returning the unconverted value of the left-side expression.</p>
3010      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3011      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3012      * anonymously, returning the actual expression in the method overriding 
3013      * {@link Var#var()}.</p>
3014      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3015      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3016      * decrements, and function calls) for the second operand unless you are quite sure 
3017      * you know exactly what you are doing.</p>
3018      * <p>Despite the fairly confusing way that this operation actually works, it is 
3019      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3020      * Although it does not actually return a boolean value, the value it returns can always 
3021      * be converted to a boolean value.</p>
3022      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3023      * re-compilations. However, in most cases you can use the logical AND operator of the 
3024      * Java language like this:
3025      * <pre>Js.be(var) && Js.be(other)</pre>
3026      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3027      * JavaScript expression since the Java compilers generally used are free to compile 
3028      * the expression into any byte codes they think efficient, making it too hard for the 
3029      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3030      * @param other A value or object.
3031      * @return The logical AND of the two operands.
3032      * @since 1.0
3033      * @javascript Re-compilers must replace the instance invocation of this method with the 
3034      * JavaScript expression:
3035      * <pre>p && other</pre>
3036      * where <tt>p</tt> is the current date instance of the invocation of this method.
3037      */
3038     public final JsDate and(JsDate other) {
3039         return Js.and(this, other);
3040     }
3041 
3042     /**
3043      * <p>Logical AND operation, resembling that of JavaScript, performs the Boolean AND 
3044      * operation on the two values: it returns <tt>true</tt> if and only if both its first 
3045      * operand and its second operand are <tt>true</tt>. If one or both of these operands 
3046      * is <tt>false</tt>, it returns <tt>false</tt>.</p>
3047      * <p>In JavaScript, depending on the value of the left-side expression, the operator 
3048      * may or may not evaluate the right-side expression. The actual behavior of the operator 
3049      * is somewhat more complicated. It starts by evaluating its first operand, the expression 
3050      * on its left. If the value of this expression can be converted to <tt>false</tt> 
3051      * (for example, if the left operand evaluates to <tt>null</tt>, 0, "", or undefined), 
3052      * the operator returns the value of the left-side expression. Otherwise, it evaluates 
3053      * its second operand, the expression on its right, and returns the value of that 
3054      * expression. In JavaScript 1.0 and JavaScript 1.1, if the left-side expression 
3055      * evaluates to <tt>false</tt>, the && operator returns <tt>false</tt> rather than 
3056      * returning the unconverted value of the left-side expression.</p>
3057      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3058      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3059      * anonymously, returning the actual expression in the method overriding 
3060      * {@link Var#var()}.</p>
3061      * <p>Sometimes, this operation probably does not do what the programmers intended. 
3062      * To avoid problems, do not use expressions with side effects (assignments, increments, 
3063      * decrements, and function calls) for the second operand unless you are quite sure 
3064      * you know exactly what you are doing.</p>
3065      * <p>Despite the fairly confusing way that this operation actually works, it is 
3066      * easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. 
3067      * Although it does not actually return a boolean value, the value it returns can always 
3068      * be converted to a boolean value.</p>
3069      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3070      * re-compilations. However, in most cases you can use the logical AND operator of the 
3071      * Java language like this:
3072      * <pre>Js.be(var) && Js.be(other)</pre>
3073      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3074      * JavaScript expression since the Java compilers generally used are free to compile 
3075      * the expression into any byte codes they think efficient, making it too hard for the 
3076      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3077      * @param other A value or object.
3078      * @return The logical AND of the two operands.
3079      * @since 1.0
3080      * @javascript Re-compilers must replace the instance invocation of this method with the 
3081      * JavaScript expression:
3082      * <pre>p && other</pre>
3083      * where <tt>p</tt> is the current date instance of the invocation of this method.
3084      */
3085     public final DateLike and(DateLike other) {
3086         return (DateLike)Js.and(this, other);
3087     }
3088 
3089     /**
3090      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3091      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3092      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3093      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3094      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3095      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3096      * its first operand, the expression on its left. If the value of this expression can 
3097      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3098      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3099      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3100      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3101      * and doesn't return the unconverted value of the left-side expression.</p>
3102      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3103      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3104      * anonymously, returning the actual expression in the method overriding 
3105      * {@link Var#var()}.</p>
3106      * <p>As with the {@link #and(Object)} operation, you should avoid right-side 
3107      * operands that include side effects, unless you purposely want to use the fact that 
3108      * the right-side expression may not be evaluated in JavaScript.</p>
3109      * <p>Even when this operation is used with operands that are not boolean values, it 
3110      * can still be considered a Boolean OR operator because its return value, whatever the 
3111      * type, can be converted to a boolean value.</p>
3112      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3113      * re-compilations. However, in most cases you can use the logical OR operator of the 
3114      * Java language like this:
3115      * <pre>Js.be(var) || Js.be(other)</pre>
3116      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3117      * JavaScript expression since the Java compilers generally used are free to compile 
3118      * the expression into any byte codes they think efficient, making it too hard for the 
3119      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3120      * @param other A value or object.
3121      * @return The logical OR of the two operands.
3122      * @since 1.0
3123      * @javascript Re-compilers must replace the instance invocation of this method with the 
3124      * JavaScript expression:
3125      * <pre>p || other</pre>
3126      * where <tt>p</tt> is the current date instance of the invocation of this method.
3127      */
3128     public final Object or(Object other) {
3129         return Js.or(this, other);
3130     }
3131 
3132     /**
3133      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3134      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3135      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3136      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3137      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3138      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3139      * its first operand, the expression on its left. If the value of this expression can 
3140      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3141      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3142      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3143      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3144      * and doesn't return the unconverted value of the left-side expression.</p>
3145      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3146      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3147      * anonymously, returning the actual expression in the method overriding 
3148      * {@link Var#var()}.</p>
3149      * <p>As with the {@link #and(Object)} operation, you should avoid right-side 
3150      * operands that include side effects, unless you purposely want to use the fact that 
3151      * the right-side expression may not be evaluated in JavaScript.</p>
3152      * <p>Even when this operation is used with operands that are not boolean values, it 
3153      * can still be considered a Boolean OR operator because its return value, whatever the 
3154      * type, can be converted to a boolean value.</p>
3155      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3156      * re-compilations. However, in most cases you can use the logical OR operator of the 
3157      * Java language like this:
3158      * <pre>Js.be(var) || Js.be(other)</pre>
3159      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3160      * JavaScript expression since the Java compilers generally used are free to compile 
3161      * the expression into any byte codes they think efficient, making it too hard for the 
3162      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3163      * @param other A value or object.
3164      * @return The logical OR of the two operands.
3165      * @since 1.0
3166      * @javascript Re-compilers must replace the instance invocation of this method with the 
3167      * JavaScript expression:
3168      * <pre>p || other</pre>
3169      * where <tt>p</tt> is the current date instance of the invocation of this method.
3170      */
3171     public final JsObject or(Var<? extends JsObject> other) {
3172         return Js.or(this, other);
3173     }
3174 
3175     /**
3176      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3177      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3178      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3179      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3180      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3181      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3182      * its first operand, the expression on its left. If the value of this expression can 
3183      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3184      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3185      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3186      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3187      * and doesn't return the unconverted value of the left-side expression.</p>
3188      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3189      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3190      * anonymously, returning the actual expression in the method overriding 
3191      * {@link Var#var()}.</p>
3192      * <p>As with the {@link #and(Object)} operation, you should avoid right-side 
3193      * operands that include side effects, unless you purposely want to use the fact that 
3194      * the right-side expression may not be evaluated in JavaScript.</p>
3195      * <p>Even when this operation is used with operands that are not boolean values, it 
3196      * can still be considered a Boolean OR operator because its return value, whatever the 
3197      * type, can be converted to a boolean value.</p>
3198      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3199      * re-compilations. However, in most cases you can use the logical OR operator of the 
3200      * Java language like this:
3201      * <pre>Js.be(var) || Js.be(other)</pre>
3202      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3203      * JavaScript expression since the Java compilers generally used are free to compile 
3204      * the expression into any byte codes they think efficient, making it too hard for the 
3205      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3206      * @param other A value or object.
3207      * @return The logical OR of the two operands.
3208      * @since 1.0
3209      * @javascript Re-compilers must replace the instance invocation of this method with the 
3210      * JavaScript expression:
3211      * <pre>p || other</pre>
3212      * where <tt>p</tt> is the current date instance of the invocation of this method.
3213      */
3214     public final JsDate or(JsDate other) {
3215         return Js.or(this, other);
3216     }
3217 
3218     /**
3219      * <p>Logical OR operation, resembling that of JavaScript, performs the Boolean OR 
3220      * operation on the two values: it returns <tt>true</tt> if either the first operand or 
3221      * the second operand is <tt>true</tt>, or if both are <tt>true</tt>. If both operands 
3222      * are <tt>false</tt>, it returns <tt>false</tt>.</p>
3223      * <p>In JavaScript, although the || operator is most often used simply as a Boolean OR 
3224      * operator, it, like the && operator, has more complex behavior. It starts by evaluating 
3225      * its first operand, the expression on its left. If the value of this expression can 
3226      * be converted to <tt>true</tt>, it returns the unconverted value of the left-side 
3227      * expression. Otherwise, it evaluates its second operand, the expression on its right, 
3228      * and returns the value of that expression. In JavaScript 1.0 and JavaScript 1.1, if the 
3229      * left-side expression can be converted to <tt>true</tt>, the operator returns <tt>true</tt> 
3230      * and doesn't return the unconverted value of the left-side expression.</p>
3231      * <p>To make the second operand really late-evaluated or not evaluated in JS Simulation 
3232      * mode, resembling what happens in JavaScript, you may have to extend {@link Var} 
3233      * anonymously, returning the actual expression in the method overriding 
3234      * {@link Var#var()}.</p>
3235      * <p>As with the {@link #and(Object)} operation, you should avoid right-side 
3236      * operands that include side effects, unless you purposely want to use the fact that 
3237      * the right-side expression may not be evaluated in JavaScript.</p>
3238      * <p>Even when this operation is used with operands that are not boolean values, it 
3239      * can still be considered a Boolean OR operator because its return value, whatever the 
3240      * type, can be converted to a boolean value.</p>
3241      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3242      * re-compilations. However, in most cases you can use the logical OR operator of the 
3243      * Java language like this:
3244      * <pre>Js.be(var) || Js.be(other)</pre>
3245      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3246      * JavaScript expression since the Java compilers generally used are free to compile 
3247      * the expression into any byte codes they think efficient, making it too hard for the 
3248      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3249      * @param other A value or object.
3250      * @return The logical OR of the two operands.
3251      * @since 1.0
3252      * @javascript Re-compilers must replace the instance invocation of this method with the 
3253      * JavaScript expression:
3254      * <pre>p || other</pre>
3255      * where <tt>p</tt> is the current date instance of the invocation of this method.
3256      */
3257     public final DateLike or(DateLike other) {
3258         return (DateLike)Js.or(this, other);
3259     }
3260 
3261     /**
3262      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3263      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3264      * operand, otherwise.</p>
3265      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3266      * boolean value. Usually this is the result of a comparison operation. The second and 
3267      * third operands may have any value. The value returned by the conditional operation 
3268      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3269      * the value of the conditional expression is the value of the second operand. If the 
3270      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3271      * value of the third operand.</p>
3272      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3273      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3274      * {@link Var} anonymously, returning the actual expression in the method overriding 
3275      * {@link Var#var()}.</p>
3276      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3277      * re-compilations. However, in most cases you can use the conditional operator of the 
3278      * Java language like this:
3279      * <pre>Js.be(test) ? var : other</pre>
3280      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3281      * JavaScript expression since the Java compilers generally used are free to compile 
3282      * the expression into any byte codes they think efficient, making it too hard for the 
3283      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3284      * @param other A value or object.
3285      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3286      * the third operand.
3287      * @since 1.0
3288      * @javascript Re-compilers must replace the instance invocation of this method with the 
3289      * JavaScript expression:
3290      * <pre>test ? p : other</pre>
3291      * where <tt>p</tt> is the current date instance of the invocation of this method.
3292      */
3293     public final Object cond(Object test, Object other) {
3294         return Js.cond(test, this, other);
3295     }
3296 
3297     /**
3298      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3299      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3300      * operand, otherwise.</p>
3301      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3302      * boolean value. Usually this is the result of a comparison operation. The second and 
3303      * third operands may have any value. The value returned by the conditional operation 
3304      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3305      * the value of the conditional expression is the value of the second operand. If the 
3306      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3307      * value of the third operand.</p>
3308      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3309      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3310      * {@link Var} anonymously, returning the actual expression in the method overriding 
3311      * {@link Var#var()}.</p>
3312      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3313      * re-compilations. However, in most cases you can use the conditional operator of the 
3314      * Java language like this:
3315      * <pre>Js.be(test) ? var : other</pre>
3316      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3317      * JavaScript expression since the Java compilers generally used are free to compile 
3318      * the expression into any byte codes they think efficient, making it too hard for the 
3319      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3320      * @param other A value or object.
3321      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3322      * the third operand.
3323      * @since 1.0
3324      * @javascript Re-compilers must replace the instance invocation of this method with the 
3325      * JavaScript expression:
3326      * <pre>test ? p : other</pre>
3327      * where <tt>p</tt> is the current date instance of the invocation of this method.
3328      */
3329     public final Number cond(Object test, Number other) {
3330         return Js.cond(test, valueOf(), other);
3331     }
3332 
3333     /**
3334      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3335      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3336      * operand, otherwise.</p>
3337      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3338      * boolean value. Usually this is the result of a comparison operation. The second and 
3339      * third operands may have any value. The value returned by the conditional operation 
3340      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3341      * the value of the conditional expression is the value of the second operand. If the 
3342      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3343      * value of the third operand.</p>
3344      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3345      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3346      * {@link Var} anonymously, returning the actual expression in the method overriding 
3347      * {@link Var#var()}.</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 conditional operator of the 
3350      * Java language like this:
3351      * <pre>Js.be(test) ? var : 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 other A value or object.
3357      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3358      * the third operand.
3359      * @since 1.0
3360      * @javascript Re-compilers must replace the instance invocation of this method with the 
3361      * JavaScript expression:
3362      * <pre>test ? p : other</pre>
3363      * where <tt>p</tt> is the current date instance of the invocation of this method.
3364      */
3365     public final Number cond(Object test, Character other) {
3366         return Js.cond(test, valueOf(), Js.valueOf(other));
3367     }
3368 
3369     /**
3370      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3371      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3372      * operand, otherwise.</p>
3373      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3374      * boolean value. Usually this is the result of a comparison operation. The second and 
3375      * third operands may have any value. The value returned by the conditional operation 
3376      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3377      * the value of the conditional expression is the value of the second operand. If the 
3378      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3379      * value of the third operand.</p>
3380      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3381      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3382      * {@link Var} anonymously, returning the actual expression in the method overriding 
3383      * {@link Var#var()}.</p>
3384      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3385      * re-compilations. However, in most cases you can use the conditional operator of the 
3386      * Java language like this:
3387      * <pre>Js.be(test) ? var : other</pre>
3388      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3389      * JavaScript expression since the Java compilers generally used are free to compile 
3390      * the expression into any byte codes they think efficient, making it too hard for the 
3391      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3392      * @param other A value or object.
3393      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3394      * the third operand.
3395      * @since 1.0
3396      * @javascript Re-compilers must replace the instance invocation of this method with the 
3397      * JavaScript expression:
3398      * <pre>test ? p : other</pre>
3399      * where <tt>p</tt> is the current date instance of the invocation of this method.
3400      */
3401     public final Number cond(Object test, Value<? extends Number> other) {
3402         return Js.cond(test, valueOf(), other);
3403     }
3404 
3405     /**
3406      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3407      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3408      * operand, otherwise.</p>
3409      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3410      * boolean value. Usually this is the result of a comparison operation. The second and 
3411      * third operands may have any value. The value returned by the conditional operation 
3412      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3413      * the value of the conditional expression is the value of the second operand. If the 
3414      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3415      * value of the third operand.</p>
3416      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3417      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3418      * {@link Var} anonymously, returning the actual expression in the method overriding 
3419      * {@link Var#var()}.</p>
3420      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3421      * re-compilations. However, in most cases you can use the conditional operator of the 
3422      * Java language like this:
3423      * <pre>Js.be(test) ? var : other</pre>
3424      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3425      * JavaScript expression since the Java compilers generally used are free to compile 
3426      * the expression into any byte codes they think efficient, making it too hard for the 
3427      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3428      * @param other A value or object.
3429      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3430      * the third operand.
3431      * @since 1.0
3432      * @javascript Re-compilers must replace the instance invocation of this method with the 
3433      * JavaScript expression:
3434      * <pre>test ? p : other</pre>
3435      * where <tt>p</tt> is the current date instance of the invocation of this method.
3436      */
3437     public final JsObject cond(Object test, Var<? extends JsObject> other) {
3438         return Js.cond(test, this, other);
3439     }
3440 
3441     /**
3442      * <p>Conditional operation, resembling the ternary operator of JavaScript, returns the 
3443      * second operand if the first operand evaluates to <tt>true</tt>; Returns the third 
3444      * operand, otherwise.</p>
3445      * <p>The first operand of the conditional operation must be (or be convertible to) a 
3446      * boolean value. Usually this is the result of a comparison operation. The second and 
3447      * third operands may have any value. The value returned by the conditional operation 
3448      * depends on the boolean value of the first operand. If that operand is <tt>true</tt>, 
3449      * the value of the conditional expression is the value of the second operand. If the 
3450      * first operand is <tt>false</tt>, the value of the conditional expression is the 
3451      * value of the third operand.</p>
3452      * <p>To make the second and third operands really late-evaluated or not evaluated in 
3453      * JS Simulation mode, resembling what happens in JavaScript, you may have to extend 
3454      * {@link Var} anonymously, returning the actual expression in the method overriding 
3455      * {@link Var#var()}.</p>
3456      * <p>Note that, this method is probably useful in emulation codes just for perfect 
3457      * re-compilations. However, in most cases you can use the conditional operator of the 
3458      * Java language like this:
3459      * <pre>Js.be(test) ? var : other</pre>
3460      * which is definitely late-evaluated but not necessarily re-compiled into an expected 
3461      * JavaScript expression since the Java compilers generally used are free to compile 
3462      * the expression into any byte codes they think efficient, making it too hard for the 
3463      * re-compilers to reconvert the byte codes to an expression in JavaScript.</p>
3464      * @param other A value or object.
3465      * @return The second operand if the first operand evaluates to <tt>true</tt>; Otherwise, 
3466      * the third operand.
3467      * @since 1.0
3468      * @javascript Re-compilers must replace the instance invocation of this method with the 
3469      * JavaScript expression:
3470      * <pre>test ? p : other</pre>
3471      * where <tt>p</tt> is the current date instance of the invocation of this method.
3472      */
3473     public final JsDate cond(Object test, JsDate other) {
3474         return Js.cond(test, this, other);
3475     }
3476 
3477     /**
3478      * <p>Performs unary negation on a 64-bit integer.</p>
3479      * <p>This operation converts a positive value to an equivalently negative value, and 
3480      * vice versa. If the operand is not a 64-bit integer, it attempts to convert it to one.</p>
3481      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3482      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3483      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3484      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3485      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3486      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3487      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3488      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3489      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3490      * bits involve the invocation of a predefined re-compiler dependent function while 
3491      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3492      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3493      * string representation of the <tt>long</tt> number in full 64-bit precision. </p>
3494      * @return The negation of the 64-bit integer.
3495      * @since 1.0
3496      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3497      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3498      * the same re-compiler would replace the byte codes of a negation operation on a long number, 
3499      * such as the byte codes compiled from the following Java expression:  
3500      * <pre>-((Number)p).longValue()</pre>
3501      * where <tt>p</tt> is the current date instance of the invocation of this method.
3502      */
3503     public final long lneg() {
3504         return Js.lneg(this);
3505     }
3506 
3507     /**
3508      * <p>The 64-bit bitwise-NOT operation, casting the operand to a <tt>long</tt> number 
3509      * if it is not 64-bit, operates by reversing all bits in the 64-bit integer.</p>
3510      * <p>Because of the way signed integers are represented in JavaScript, applying this 
3511      * operation to a value is equivalent to changing its sign and subtracting 1.</p>
3512      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3513      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3514      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3515      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3516      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3517      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3518      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3519      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3520      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3521      * bits involve the invocation of a predefined re-compiler dependent function while 
3522      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3523      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3524      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3525      * @return The bitwise-NOT of the 64-bit integer.
3526      * @since 1.0
3527      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3528      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3529      * the same re-compiler would replace the byte codes of a bitwise-NOT operation on a long number, 
3530      * such as the byte codes compiled from the following Java expression:  
3531      * <pre>~((Number)p).longValue()</pre>
3532      * where <tt>p</tt> is the current date instance of the invocation of this method.
3533      */
3534     public final long lnot() {
3535         return Js.lnot(this);
3536     }
3537 
3538     /**
3539      * <p>Adds two 64-bit integers, casting the operands to <tt>long</tt> numbers if any 
3540      * one of them is not a 64-bit integer.</p>
3541      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3542      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3543      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3544      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3545      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3546      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3547      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3548      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3549      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3550      * bits involve the invocation of a predefined re-compiler dependent function while 
3551      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3552      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3553      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3554      * @param other Any numeric value.
3555      * @return The sum of the two 64-bit integers.
3556      * @since 1.0
3557      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3558      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3559      * the same re-compiler would replace the byte codes of an addition operation on two long numbers, 
3560      * such as the byte codes compiled from the following Java expression:  
3561      * <pre>((Number)p).longValue() + ((Number)other).longValue()</pre>
3562      * where <tt>p</tt> is the current date instance of the invocation of this method.
3563      */
3564     public final long ladd(Object other) {
3565         return Js.ladd(this, other);
3566     }
3567 
3568     /**
3569      * <p>Subtracts the second 64-bit integer from the first 64-bit integer, casting the 
3570      * operands to <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
3571      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3572      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3573      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3574      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3575      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3576      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3577      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3578      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3579      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3580      * bits involve the invocation of a predefined re-compiler dependent function while 
3581      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3582      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3583      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3584      * @param other Any numeric value.
3585      * @return The difference between the two 64-bit integers.
3586      * @since 1.0
3587      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3588      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3589      * the same re-compiler would replace the byte codes of a subtraction operation on two long numbers, 
3590      * such as the byte codes compiled from the following Java expression:  
3591      * <pre>((Number)p).longValue() - ((Number)other).longValue()</pre>
3592      * where <tt>p</tt> is the current date instance of the invocation of this method.
3593      */
3594     public final long lsub(Object other) {
3595         return Js.lsub(this, other);
3596     }
3597 
3598     /**
3599      * <p>Multiplies the two 64-bit integer, casting the operands to <tt>long</tt> numbers 
3600      * if any one of them is not a 64-bit integer.</p>
3601      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3602      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3603      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3604      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3605      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3606      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3607      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3608      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3609      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3610      * bits involve the invocation of a predefined re-compiler dependent function while 
3611      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3612      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3613      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3614      * @param other Any numeric value.
3615      * @return The product of the two 64-bit integers.
3616      * @since 1.0
3617      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3618      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3619      * the same re-compiler would replace the byte codes of a multiplication operation on two long numbers, 
3620      * such as the byte codes compiled from the following Java expression:  
3621      * <pre>((Number)p).longValue() * ((Number)other).longValue()</pre>
3622      * where <tt>p</tt> is the current date instance of the invocation of this method.
3623      */
3624     public final long lmul(Object other) {
3625         return Js.lmul(this, other);
3626     }
3627 
3628     /**
3629      * <p>Divides the first 64-bit integer by the second 64-bit integer, casting the operands 
3630      * to <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
3631      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3632      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3633      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3634      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3635      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3636      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3637      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3638      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3639      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3640      * bits involve the invocation of a predefined re-compiler dependent function while 
3641      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3642      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3643      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3644      * @param other Any numeric value.
3645      * @return The quotient of the two 64-bit integers.
3646      * @since 1.0
3647      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3648      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3649      * the same re-compiler would replace the byte codes of an division operation on two long numbers, 
3650      * such as the byte codes compiled from the following Java expression:  
3651      * <pre>((Number)p).longValue() / ((Number)other).longValue()</pre>
3652      * where <tt>p</tt> is the current date instance of the invocation of this method.
3653      */
3654     public final long ldiv(Object other) {
3655         return Js.ldiv(this, other);
3656     }
3657 
3658     /**
3659      * <p>Computes the first operand modulo the second operand, casting the operands to 
3660      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
3661      * <p>The operation returns the remainder when the first operand is divided by the 
3662      * second operand a certain number of times. The sign of the result is the same as the 
3663      * sign of the first operand.</p>
3664      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3665      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3666      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3667      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3668      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3669      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3670      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3671      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3672      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3673      * bits involve the invocation of a predefined re-compiler dependent function while 
3674      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3675      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3676      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3677      * @param other Any numeric value.
3678      * @return The remainder.
3679      * @since 1.0
3680      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3681      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3682      * the same re-compiler would replace the byte codes of a modulo operation on two long numbers, 
3683      * such as the byte codes compiled from the following Java expression:  
3684      * <pre>((Number)p).longValue() % ((Number)other).longValue()</pre>
3685      * where <tt>p</tt> is the current date instance of the invocation of this method.
3686      */
3687     public final long lmod(Object other) {
3688         return Js.lmod(this, other);
3689     }
3690 
3691     /**
3692      * <p>The 64-bit shift-left operation, casting the first operand to a <tt>long</tt> 
3693      * number if it is not 64-bit, moves all bits in it to the left by the number of places 
3694      * specified in the second operand, which should be an integer between 0 and 63.</p>
3695      * <p>A zero is used for the new first bit, and the value of the 64th bit is lost. 
3696      * Shifting a value left by one position is equivalent to multiplying by 2, shifting 
3697      * two positions is equivalent to multiplying by 4, etc.</p>
3698      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3699      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3700      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3701      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3702      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3703      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3704      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3705      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3706      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3707      * bits involve the invocation of a predefined re-compiler dependent function while 
3708      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3709      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3710      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3711      * @param n The number of bits to shift.
3712      * @return The shifted 64-bit integer.
3713      * @since 1.0
3714      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3715      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3716      * the same re-compiler would replace the byte codes of a shift-left operation on a long number, 
3717      * such as the byte codes compiled from the following Java expression:  
3718      * <pre>((Number)p).longValue() << n</pre>
3719      * where <tt>p</tt> is the current date instance of the invocation of this method.
3720      */
3721     public final long lshl(int n) {
3722         return Js.lshl(this, n);
3723     }
3724 
3725     /**
3726      * <p>The 64-bit shift-right operation, casting the first operand to a <tt>long</tt> 
3727      * number if it is not 64-bit, moves all bits in it to the right by the number of 
3728      * places specified in the second operand (an integer between 0 and 63). Bits that are 
3729      * shifted off the right are lost. The bits filled in on the left depend on the sign 
3730      * bit of the original operand, in order to preserve the sign of the result. If the 
3731      * first operand is positive, the result has zeros placed in the high bits; if the 
3732      * first operand is negative, the result has ones placed in the high bits.</p>
3733      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
3734      * remainder), shifting right two places is equivalent to integer division by 4, and 
3735      * so on.</p>
3736      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3737      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3738      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3739      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3740      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3741      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3742      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3743      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3744      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3745      * bits involve the invocation of a predefined re-compiler dependent function while 
3746      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3747      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3748      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3749      * @param n The number of bits to shift.
3750      * @return The shifted 64-bit integer.
3751      * @since 1.0
3752      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3753      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3754      * the same re-compiler would replace the byte codes of a shift-right operation on a long number, 
3755      * such as the byte codes compiled from the following Java expression:  
3756      * <pre>((Number)p).longValue() >> n</pre>
3757      * where <tt>p</tt> is the current date instance of the invocation of this method.
3758      */
3759     public final long lshr(int n) {
3760         return Js.lshr(this, n);
3761     }
3762 
3763     /**
3764      * <p>The 64-bit shift-right-unsigned operation, casting the first operand to a 
3765      * <tt>long</tt> number if it is not 64-bit, moves all bits in it to the right by the 
3766      * number of places specified in the second operand (an integer between 0 and 63). Bits 
3767      * that are shifted off the right are lost. The result has zeros placed in the high 
3768      * bits.</p>
3769      * <p>This operation is just like {@link #lshr(int)}, except that the bits shifted 
3770      * in on the left are always zero, regardless of the sign of the first operand.</p>
3771      * <p>Shifting a value right one place is equivalent to dividing by 2 (discarding the 
3772      * remainder), shifting right two places is equivalent to integer division by 4, and 
3773      * so on.</p>
3774      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3775      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3776      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3777      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3778      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3779      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3780      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3781      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3782      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3783      * bits involve the invocation of a predefined re-compiler dependent function while 
3784      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3785      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3786      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3787      * @param n The number of bits to shift.
3788      * @return The shifted 64-bit integer.
3789      * @since 1.0
3790      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3791      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3792      * the same re-compiler would replace the byte codes of an unsigned shift-right operation on a long number, 
3793      * such as the byte codes compiled from the following Java expression:  
3794      * <pre>((Number)p).longValue() >>> n</pre>
3795      * where <tt>p</tt> is the current date instance of the invocation of this method.
3796      */
3797     public final long lshru(int n) {
3798         return Js.lshru(this, n);
3799     }
3800 
3801     /**
3802      * <p>The 64-bit bitwise-AND operation, casting the operands to <tt>long</tt> numbers 
3803      * if any one of them is not a 64-bit integer, performs a boolean AND operation on each 
3804      * bit of the 64-bit integers. A bit is set in the result only if the corresponding 
3805      * bit is set in both operands.</p>
3806      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3807      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3808      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3809      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3810      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3811      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3812      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3813      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3814      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3815      * bits involve the invocation of a predefined re-compiler dependent function while 
3816      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3817      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3818      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3819      * @param other Any numeric value.
3820      * @return The bitwise-AND of the two 64-bit integers.
3821      * @since 1.0
3822      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3823      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3824      * the same re-compiler would replace the byte codes of a bitwise AND operation on two long numbers, 
3825      * such as the byte codes compiled from the following Java expression:  
3826      * <pre>((Number)p).longValue() & ((Number)other).longValue()</pre>
3827      * where <tt>p</tt> is the current date instance of the invocation of this method.
3828      */
3829     public final long land(Object other) {
3830         return Js.land(valueOf(), other);
3831     }
3832 
3833     /**
3834      * <p>The 64-bit bitwise-OR operation, casting the operands to <tt>long</tt> numbers if 
3835      * any one of them is not a 64-bit integer, performs a boolean OR operation on each bit 
3836      * of the 64-bit integers. A bit is set in the result if the corresponding bit is set 
3837      * in one or both of the operands.</p>
3838      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3839      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3840      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3841      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3842      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3843      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3844      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3845      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3846      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3847      * bits involve the invocation of a predefined re-compiler dependent function while 
3848      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3849      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3850      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3851      * @param other Any numeric value.
3852      * @return The bitwise-OR of the two 64-bit integers.
3853      * @since 1.0
3854      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3855      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3856      * the same re-compiler would replace the byte codes of a bitwise OR operation on two long numbers, 
3857      * such as the byte codes compiled from the following Java expression:  
3858      * <pre>((Number)p).longValue() | ((Number)other).longValue()</pre>
3859      * where <tt>p</tt> is the current date instance of the invocation of this method.
3860      */
3861     public final long lor(Object other) {
3862         return Js.lor(valueOf(), other);
3863     }
3864 
3865     /**
3866      * <p>The 64-bit bitwise-XOR operation, casting the operands to <tt>long</tt> numbers 
3867      * if any one of them is not a 64-bit integer, performs a boolean exclusive OR operation 
3868      * on each bit of the 64-bit integers. Exclusive OR means that either operand one is 
3869      * <tt>true</tt> or operand two is <tt>true</tt>, but not both. A bit is set in this 
3870      * operation's result if a corresponding bit is set in one (but not both) of the two 
3871      * operands.</p>
3872      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3873      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3874      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3875      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3876      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3877      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3878      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3879      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3880      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3881      * bits involve the invocation of a predefined re-compiler dependent function while 
3882      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3883      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3884      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3885      * @param other Any numeric value.
3886      * @return The bitwise-exclusive-OR of the two 64-bit integers.
3887      * @since 1.0
3888      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3889      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3890      * the same re-compiler would replace the byte codes of a bitwise exclusive OR operation on two long numbers, 
3891      * such as the byte codes compiled from the following Java expression:  
3892      * <pre>((Number)p).longValue() ^ ((Number)other).longValue()</pre>
3893      * where <tt>p</tt> is the current date instance of the invocation of this method.
3894      */
3895     public final long lxor(Object other) {
3896         return Js.lxor(valueOf(), other);
3897     }
3898 
3899     /**
3900      * <p>The 64-bit less-than operation, casting the operands to <tt>long</tt> numbers if 
3901      * any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the first 
3902      * operand is less than the second operand; otherwise it evaluates to <tt>false</tt>.</p>
3903      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3904      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3905      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3906      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3907      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3908      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3909      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3910      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3911      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3912      * bits involve the invocation of a predefined re-compiler dependent function while 
3913      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3914      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3915      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3916      * @param other Any numeric value.
3917      * @return <tt>true</tt> if the first operand is less than the second operand; 
3918      * otherwise <tt>false</tt>.
3919      * @since 1.0
3920      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3921      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3922      * the same re-compiler would replace the byte codes of a less-than operation on two long numbers, 
3923      * such as the byte codes compiled from the following Java expression:  
3924      * <pre>((Number)p).longValue() < ((Number)other).longValue()</pre>
3925      * where <tt>p</tt> is the current date instance of the invocation of this method.
3926      */
3927     public final boolean llt(Object other) {
3928         return Js.llt(valueOf(), other);
3929     }
3930 
3931     /**
3932      * <p>The 64-bit greater-than operation, casting the operands to <tt>long</tt> numbers 
3933      * if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the first 
3934      * operand is greater than the second operand; otherwise it evaluates to <tt>false</tt>.</p>
3935      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3936      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3937      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3938      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3939      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3940      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3941      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3942      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3943      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3944      * bits involve the invocation of a predefined re-compiler dependent function while 
3945      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3946      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3947      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3948      * @param other Any numeric value.
3949      * @return <tt>true</tt> if the first operand is greater than the second operand; 
3950      * otherwise <tt>false</tt>.
3951      * @since 1.0
3952      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3953      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3954      * the same re-compiler would replace the byte codes of a greater-than operation on two long numbers, 
3955      * such as the byte codes compiled from the following Java expression:  
3956      * <pre>((Number)p).longValue() > ((Number)other).longValue()</pre>
3957      * where <tt>p</tt> is the current date instance of the invocation of this method.
3958      */
3959     public final boolean lgt(Object other) {
3960         return Js.lgt(valueOf(), other);
3961     }
3962 
3963     /**
3964      * <p>The 64-bit less-than-or-equal operation, casting the operands to <tt>long</tt> 
3965      * numbers if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if 
3966      * the first operand is less than or equal to the second operand; otherwise it evaluates 
3967      * to <tt>false</tt>.</p>
3968      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
3969      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
3970      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
3971      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
3972      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
3973      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
3974      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
3975      * naturally evaluates to a normal number without extra casting codes. That is, casting 
3976      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
3977      * bits involve the invocation of a predefined re-compiler dependent function while 
3978      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
3979      * In addition, the <tt>toString()</tt> method of that object or array must return a 
3980      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
3981      * @param other Any numeric value.
3982      * @return <tt>true</tt> if the first operand is less than or equal to the second operand; 
3983      * otherwise <tt>false</tt>.
3984      * @since 1.0
3985      * @javascript A re-compiler is expected to replace the instance invocation of this method 
3986      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
3987      * the same re-compiler would replace the byte codes of a less-than-or-equal operation on two long numbers, 
3988      * such as the byte codes compiled from the following Java expression:  
3989      * <pre>((Number)p).longValue() <= ((Number)other).longValue()</pre>
3990      * where <tt>p</tt> is the current date instance of the invocation of this method.
3991      */
3992     public final boolean llte(Object other) {
3993         return Js.llte(valueOf(), other);
3994     }
3995 
3996     /**
3997      * <p>The 64-bit greater-than-or-equal operation, casting the operands to <tt>long</tt> 
3998      * numbers if any one of them is not a 64-bit integer, evaluates to <tt>true</tt> if the 
3999      * first operand is greater than or equal to the second operand; otherwise it evaluates 
4000      * to <tt>false</tt>.</p>
4001      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
4002      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
4003      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
4004      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
4005      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
4006      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
4007      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
4008      * naturally evaluates to a normal number without extra casting codes. That is, casting 
4009      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
4010      * bits involve the invocation of a predefined re-compiler dependent function while 
4011      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
4012      * In addition, the <tt>toString()</tt> method of that object or array must return a 
4013      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
4014      * @param other Any numeric value.
4015      * @return <tt>true</tt> if the first operand is greater than or equal to the second operand; 
4016      * otherwise <tt>false</tt>.
4017      * @since 1.0
4018      * @javascript A re-compiler is expected to replace the instance invocation of this method 
4019      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
4020      * the same re-compiler would replace the byte codes of a greater-than-or-equal operation on two long numbers, 
4021      * such as the byte codes compiled from the following Java expression:  
4022      * <pre>((Number)p).longValue() >= ((Number)other).longValue()</pre>
4023      * where <tt>p</tt> is the current date instance of the invocation of this method.
4024      */
4025     public final boolean lgte(Object other) {
4026         return Js.lgte(valueOf(), other);
4027     }
4028 
4029     /**
4030      * <p>Checks whether the two 64-bit integers are "equal", casting the operands to 
4031      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
4032      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
4033      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
4034      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
4035      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
4036      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
4037      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
4038      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
4039      * naturally evaluates to a normal number without extra casting codes. That is, casting 
4040      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
4041      * bits involve the invocation of a predefined re-compiler dependent function while 
4042      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
4043      * In addition, the <tt>toString()</tt> method of that object or array must return a 
4044      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
4045      * @param other Any numeric value.
4046      * @return <tt>true</tt> if the first operand equals the second; <tt>false</tt>, 
4047      * otherwise;
4048      * @since 1.0
4049      * @javascript A re-compiler is expected to replace the instance invocation of this method 
4050      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
4051      * the same re-compiler would replace the byte codes of an equality operation on two long numbers, 
4052      * such as the byte codes compiled from the following Java expression:  
4053      * <pre>((Number)p).longValue() == ((Number)other).longValue()</pre>
4054      * where <tt>p</tt> is the current date instance of the invocation of this method.
4055      */
4056     public final boolean leq(Object other) {
4057         return Js.leq(valueOf(), other);
4058     }
4059 
4060     /**
4061      * <p>Checks whether the two 64-bit integers are not "equal", casting the operands to 
4062      * <tt>long</tt> numbers if any one of them is not a 64-bit integer.</p>
4063      * <p>Note that, although the representation of <tt>long</tt> numbers in JavaScript and 
4064      * the 64-bit operations on them are re-compiler dependent, the re-compilers are expected 
4065      * to express 64-bit integers as JavaScript objects or arrays, with a bitwise or arithmetc 
4066      * operation on <tt>long</tt> numbers converted to the invocation of a predefined global 
4067      * function that is also re-compiler dependent. The <tt>valueOf()</tt> method of the object 
4068      * or array representing a 64-bit integer must return a number representing the <tt>long</tt> 
4069      * number in JavaScript limited bits range, so that a <tt>long</tt> integer in JavaScript 
4070      * naturally evaluates to a normal number without extra casting codes. That is, casting 
4071      * a normal number to a <tt>long</tt> integer, or creating a <tt>long</tt> integer from 
4072      * bits involve the invocation of a predefined re-compiler dependent function while 
4073      * casting a <tt>long</tt> integer to a normal number is expected to be ignored by re-compilation. 
4074      * In addition, the <tt>toString()</tt> method of that object or array must return a 
4075      * string representation of the <tt>long</tt> number in full 64-bit precision.</p>
4076      * @param other Any numeric value.
4077      * @return <tt>false</tt> if the first operand equals the second; <tt>true</tt>, 
4078      * otherwise;
4079      * @since 1.0
4080      * @javascript A re-compiler is expected to replace the instance invocation of this method 
4081      * with the invocation of a predefined and re-compiler dependent function, with an invocation of which 
4082      * the same re-compiler would replace the byte codes of an inequality operation on two long numbers, 
4083      * such as the byte codes compiled from the following Java expression:  
4084      * <pre>((Number)p).longValue() != ((Number)other).longValue()</pre>
4085      * where <tt>p</tt> is the current date instance of the invocation of this method.
4086      */
4087     public final boolean lneq(Object other) {
4088         return Js.lneq(valueOf(), other);
4089     }
4090 }