jsduck 3.0.pre → 3.0.pre2

data/js-classes/Object.js

@@ -0,0 +1,404 @@
+/**
+ * @class Object
+ *
+ * Creates an object wrapper.
+ *
+ * The Object constructor creates an object wrapper for the given value. If the value is null or
+ * undefined, it will create and return an empty object, otherwise, it will return an object of a type
+ * that corresponds to the given value.
+ *
+ * When called in a non-constructor context, Object behaves identically.
+ *
+ * # Using Object given undefined and null types
+ *
+ * The following examples store an empty Object object in o:
+ *     var o = new Object();
+ *
+ *     var o = new Object(undefined);
+ *
+ *     var o = new Object(null);
+ *
+ * # Using Object to create Boolean objects
+ *
+ * The following examples store Boolean objects in o:
+ *
+ *     // equivalent to o = new Boolean(true);
+ *     var o = new Object(true);
+ *
+ *     // equivalent to o = new Boolean(false);
+ *     var o = new Object(Boolean());
+ *
+ * <div class="notice">
+ * Documentation for this class comes from <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object">MDN</a>
+ * and is available under <a href="http://creativecommons.org/licenses/by-sa/2.0/">Creative Commons: Attribution-Sharealike license</a>.
+ * </div>
+ */
+
+/**
+ * @method constructor
+ * Creates new Object.
+ * @param {Object} [value] The value to wrap.
+ */
+
+//Properties
+
+/**
+ * @property prototype
+ * Allows the addition of properties to all objects of type Object.
+ */
+
+//Methods
+
+/**
+ * @method hasOwnProperty
+ * Returns a boolean indicating whether an object contains the specified property as a direct property
+ * of that object and not inherited through the prototype chain.
+ *
+ * Every object descended from `Object` inherits the `hasOwnProperty` method. This method can be used
+ * to determine whether an object has the specified property as a direct property of that object;
+ * unlike the `in` operator, this method does not check down the object's prototype chain.
+ *
+ * The following example determines whether the o object contains a property named prop:
+ *
+ *     o = new Object();
+ *     o.prop = 'exists';
+ *
+ *     function changeO() {
+ *         o.newprop = o.prop;
+ *         delete o.prop;
+ *     }
+ *
+ *     o.hasOwnProperty('prop');   //returns true
+ *     changeO();
+ *     o.hasOwnProperty('prop');   //returns false
+ *
+ * The following example differentiates between direct properties and properties inherited through the
+ * prototype chain:
+ *
+ *     o = new Object();
+ *     o.prop = 'exists';
+ *     o.hasOwnProperty('prop');             // returns true
+ *     o.hasOwnProperty('toString');         // returns false
+ *     o.hasOwnProperty('hasOwnProperty');   // returns false
+ *
+ * The following example shows how to iterate over the properties of an object without executing on
+ * inherit properties.
+ *
+ *     var buz = {
+ *         fog: 'stack'
+ *     };
+ *
+ *     for (var name in buz) {
+ *         if (buz.hasOwnProperty(name)) {
+ *             alert("this is fog (" + name + ") for sure. Value: " + buz[name]);
+ *         }
+ *         else {
+ *             alert(name); // toString or something else
+ *         }
+ *     }
+ *
+ * @param {String} prop The name of the property to test.
+ * @return {Boolean} Returns true if object contains specified property; else
+ * returns false.
+ */
+
+/**
+ * @method isPrototypeOf
+ * Returns a boolean indication whether the specified object is in the prototype chain of the object
+ * this method is called upon.
+ *
+ * `isPrototypeOf` allows you to check whether or not an object exists within another object's
+ * prototype chain.
+ *
+ * For example, consider the following prototype chain:
+ *
+ *     function Fee() {
+ *         // . . .
+ *     }
+ *
+ *     function Fi() {
+ *         // . . .
+ *     }
+ *     Fi.prototype = new Fee();
+ *
+ *     function Fo() {
+ *         // . . .
+ *     }
+ *     Fo.prototype = new Fi();
+ *
+ *     function Fum() {
+ *         // . . .
+ *     }
+ *     Fum.prototype = new Fo();
+ *
+ * Later on down the road, if you instantiate `Fum` and need to check if `Fi`'s prototype exists
+ * within the `Fum` prototype chain, you could do this:
+ *
+ *     var fum = new Fum();
+ *     . . .
+ *
+ *     if (Fi.prototype.isPrototypeOf(fum)) {
+ *     // do something safe
+ *     }
+ *
+ * This, along with the `instanceof` operator particularly comes in handy if you have code that can
+ * only function when dealing with objects descended from a specific prototype chain, e.g., to
+ * guarantee that certain methods or properties will be present on that object.
+ *
+ * @param {Object} prototype an object to be tested against each link in the prototype chain of the
+ * *object* argument
+ * @param {Object} object the object whose prototype chain will be searched
+ * @return {Boolean} Returns true if object is a prototype and false if not.
+ */
+
+/**
+ * @method propertyIsEnumerable
+ * Returns a boolean indicating if the internal ECMAScript DontEnum attribute is set.
+ *
+ * Every object has a `propertyIsEnumerable` method. This method can determine whether the specified
+ * property in an object can be enumerated by a `for...in` loop, with the exception of properties
+ * inherited through the prototype chain. If the object does not have the specified property, this
+ * method returns false.
+ *
+ * The following example shows the use of `propertyIsEnumerable` on objects and arrays:
+ *
+ *     var o = {};
+ *     var a = [];
+ *     o.prop = 'is enumerable';
+ *     a[0] = 'is enumerable';
+ *
+ *     o.propertyIsEnumerable('prop');   // returns true
+ *     a.propertyIsEnumerable(0);        // returns true
+ *
+ * The following example demonstrates the enumerability of user-defined versus built-in properties:
+ *
+ *     var a = ['is enumerable'];
+ *
+ *     a.propertyIsEnumerable(0);          // returns true
+ *     a.propertyIsEnumerable('length');   // returns false
+ *
+ *     Math.propertyIsEnumerable('random');   // returns false
+ *     this.propertyIsEnumerable('Math');     // returns false
+ *
+ * Direct versus inherited properties
+ *
+ *     var a = [];
+ *     a.propertyIsEnumerable('constructor');         // returns false
+ *
+ *     function firstConstructor()
+ *     {
+ *         this.property = 'is not enumerable';
+ *     }
+ *     firstConstructor.prototype.firstMethod = function () {};
+ *
+ *     function secondConstructor()
+ *     {
+ *         this.method = function method() { return 'is enumerable'; };
+ *     }
+ *
+ *     secondConstructor.prototype = new firstConstructor;
+ *     secondConstructor.prototype.constructor = secondConstructor;
+ *
+ *     var o = new secondConstructor();
+ *     o.arbitraryProperty = 'is enumerable';
+ *
+ *     o.propertyIsEnumerable('arbitraryProperty');   // returns true
+ *     o.propertyIsEnumerable('method');              // returns true
+ *     o.propertyIsEnumerable('property');            // returns false
+ *
+ *     o.property = 'is enumerable';
+ *
+ *     o.propertyIsEnumerable('property');            // returns true
+ *
+ *     // These return false as they are on the prototype which
+ *     // propertyIsEnumerable does not consider (even though the last two
+ *     // are iteratable with for-in)
+ *     o.propertyIsEnumerable('prototype'); // returns false (as of JS 1.8.1/FF3.6)
+ *     o.propertyIsEnumerable('constructor'); // returns false
+ *     o.propertyIsEnumerable('firstMethod'); // returns false
+ *
+ * @param {String} prop The name of the property to test.
+ * @return {Boolean} If the object does not have the specified property, this
+ * method returns false.
+ */
+
+/**
+ * @method toLocaleString
+ * Returns a string representing the object. This method is meant to be overridden by derived objects
+ * for locale-specific purposes.
+ *
+ * `Object`'s `toLocaleString` returns the result of calling `toString`.
+ *
+ * This function is provided to give objects a generic `toLocaleString` method, even though not all
+ * may use it. Currently, only `Array`, `Number`, and `Date` override `toLocaleString`.
+ *
+ * @return {String} Object represented as a string.
+ */
+
+/**
+ * @method toString
+ * Returns a string representation of the object.
+ *
+ * Every object has a `toString()` method that is automatically called when the object is to be
+ * represented as a text value or when an object is referred to in a manner in which a string is
+ * expected. By default, the `toString()` method is inherited by every object descended from `Object`.
+ * If this method is not overridden in a custom object, `toString()` returns "[object type]", where
+ * `type` is the object type. The following code illustrates this:
+ *
+ *     var o = new Object();
+ *     o.toString();           // returns [object Object]
+ *
+ * You can create a function to be called in place of the default `toString()` method. The
+ * `toString()` method takes no arguments and should return a string. The `toString()` method you
+ * create can be any value you want, but it will be most useful if it carries information about the
+ * object.
+ *
+ * The following code defines the `Dog` object type and creates `theDog`, an object of type `Dog`:
+ *
+ *     function Dog(name,breed,color,sex) {
+ *         this.name=name;
+ *         this.breed=breed;
+ *         this.color=color;
+ *         this.sex=sex;
+ *     }
+ *
+ *     theDog = new Dog("Gabby","Lab","chocolate","female");
+ *
+ * If you call the `toString()` method on this custom object, it returns the default value inherited
+ * from `Object`:
+ *
+ *     theDog.toString(); //returns [object Object]
+ *
+ * The following code creates and assigns `dogToString()` to override the default `toString()` method.
+ * This function generates a string containing the name, breed, color, and sex of the object, in the
+ * form `"property = value;"`.
+ *
+ *     Dog.prototype.toString = function dogToString() {
+ *         var ret = "Dog " + this.name + " is a " + this.sex + " " + this.color + " " + this.breed;
+ *         return ret;
+ *     }
+ *
+ * With the preceding code in place, any time theDog is used in a string context, JavaScript
+ * automatically calls the `dogToString()` function, which returns the following string:
+ *
+ *     Dog Gabby is a female chocolate Lab
+ *
+ * `toString()` can be used with every object and allows you to get its class. To use the
+ * `Object.prototype.toString()` with every object, you need to call `Function.prototype.call()` or
+ * `Function.prototype.apply()` on it, passing the object you want to inspect as the first parameter
+ * called `thisArg`.
+ *
+ *     var toString = Object.prototype.toString;
+ *
+ *     toString.call(new Date); // [object Date]
+ *     toString.call(new String); // [object String]
+ *     toString.call(Math); // [object Math]
+ *
+ * @return {String} Object represented as a string.
+ */
+
+/**
+ * @method valueOf
+ * Returns the primitive value of the specified object.
+ *
+ * JavaScript calls the `valueOf` method to convert an object to a primitive value. You rarely need to
+ * invoke the `valueOf` method yourself; JavaScript automatically invokes it when encountering an
+ * object where a primitive value is expected.
+ *
+ * By default, the `valueOf` method is inherited by every object descended from `Object`. Every built-
+ * in core object overrides this method to return an appropriate value. If an object has no primitive
+ * value, `valueOf` returns the object itself, which is displayed as:
+ *
+ *     [object Object]
+ *
+ * You can use `valueOf` within your own code to convert a built-in object into a primitive value.
+ * When you create a custom object, you can override `Object.valueOf` to call a custom method instead
+ * of the default `Object` method.
+ *
+ * You can create a function to be called in place of the default `valueOf` method. Your function must
+ * take no arguments.
+ *
+ * Suppose you have an object type `myNumberType` and you want to create a `valueOf` method for it.
+ * The following code assigns a user-defined function to the object's valueOf method:
+ *
+ *     myNumberType.prototype.valueOf = new Function(functionText)
+ *
+ * With the preceding code in place, any time an object of type `myNumberType` is used in a context
+ * where it is to be represented as a primitive value, JavaScript automatically calls the function
+ * defined in the preceding code.
+ *
+ * An object's `valueOf` method is usually invoked by JavaScript, but you can invoke it yourself as
+ * follows:
+ *
+ *     myNumber.valueOf()
+ *
+ * Note: Objects in string contexts convert via the `toString` method, which is different from
+ * `String` objects converting to string primitives using `valueOf`. All objects have a string
+ * conversion, if only `"[object type]"`. But many objects do not convert to number, boolean, or
+ * function.
+ *
+ * @return {Object} Returns value of the object or the object itself.
+ */
+
+//Properties
+
+/**
+ * @property constructor
+ * Specifies the function that creates an object's prototype.
+ *
+ * Returns a reference to the Object function that created the instance's prototype. Note that the
+ * value of this property is a reference to the function itself, not a string containing the
+ * function's name, but it isn't read only (except for primitive Boolean, Number or String values: 1,
+ * true, "read-only").
+ *
+ * All objects inherit a `constructor` property from their `prototype`:
+ *
+ *     o = new Object // or o = {} in JavaScript 1.2
+ *     o.constructor == Object
+ *     a = new Array // or a = [] in JavaScript 1.2
+ *     a.constructor == Array
+ *     n = new Number(3)
+ *     n.constructor == Number
+ *
+ * Even though you cannot construct most HTML objects, you can do comparisons. For example,
+ *
+ *     document.constructor == Document
+ *     document.form3.constructor == Form
+ *
+ * The following example creates a prototype, `Tree`, and an object of that type, theTree. The example then displays the `constructor` property for the object `theTree`.
+ *
+ *     function Tree(name) {
+ *         this.name = name;
+ *     }
+ *     theTree = new Tree("Redwood");
+ *     console.log("theTree.constructor is " + theTree.constructor);
+ *
+ * This example displays the following output:
+ *
+ *     theTree.constructor is function Tree(name) {
+ *         this.name = name;
+ *     }
+ *
+ * The following example shows how to modify constructor value of generic objects. Only true, 1 and
+ * "test" variable constructors will not be changed. This example explains that is not always so safe
+ * to believe in constructor function.
+ *
+ *     function Type(){};
+ *     var	types = [
+ * 	    new Array,	[],
+ *	    new Boolean,	true,
+ *	    new Date,
+ *	    new Error,
+ *	    new Function,	function(){},
+ *	    Math,
+ *	    new Number,	1,
+ *	    new Object,	{},
+ *	    new RegExp,	/(?:)/,
+ *	    new String,	"test"
+ *     ];
+ *     for(var i = 0; i < types.length; i++){
+ *         types[i].constructor = Type;
+ *         types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()];
+ *     };
+ *     alert(types.join("\n"));
+ */

data/js-classes/RegExp.js

@@ -0,0 +1,415 @@
+/**
+ * @class RegExp
+ *
+ * Creates a regular expression object for matching text according to a pattern.
+ *
+ * When using the constructor function, the normal string escape rules (preceding
+ * special characters with \ when included in a string) are necessary. For
+ * example, the following are equivalent:
+ *
+ *     var re = new RegExp("\\w+");
+ *     var re = /\w+/;
+ *
+ * Notice that the parameters to the literal format do not use quotation marks to
+ * indicate strings, while the parameters to the constructor function do use
+ * quotation marks. So the following expressions create the same regular
+ * expression:
+ *
+ *     /ab+c/i;
+ *     new RegExp("ab+c", "i");
+ *
+ * # Special characters in regular expressions
+ *
+ * |     Character    | Meaning
+ * |:-----------------|:--------------------------------------------------------------------------------------
+ * | `\`              | For characters that are usually treated literally, indicates that the next character
+ * |                  | is special and not to be interpreted literally.
+ * |                  | For example, `/b/` matches the character 'b'. By placing a backslash in front of b, that
+ * |                  | is by using `/\b/`, the character becomes special to mean match a word boundary.
+ * |                  |
+ * |                  | _or_
+ * |                  |
+ * |                  | For characters that are usually treated specially, indicates that the next character is
+ * |                  | not special and should be interpreted literally.
+ * |                  |
+ * |                  | For example, `*` is a special character that means 0 or more occurrences of the preceding
+ * |                  | character should be matched; for example, `/a*\/` means match 0 or more "a"s. To match *
+ * |                  | literally, precede it with a backslash; for example, `/a\*\/` matches 'a*'.
+ * |                  |
+ * | `^`              | Matches beginning of input. If the multiline flag is set to true, also matches
+ * |                  | immediately after a line break character.
+ * |                  |
+ * |                  | For example, `/^A/` does not match the 'A' in "an A", but does match the first 'A' in
+ * |                  | "An A".
+ * |                  |
+ * | `$`              | Matches end of input. If the multiline flag is set to true, also matches immediately
+ * |                  | before a line break character.
+ * |                  |
+ * |                  | For example, `/t$/` does not match the 't' in "eater", but does match it in "eat".
+ * |                  |
+ * | `*`              | Matches the preceding item 0 or more times.
+ * |                  |
+ * |                  | For example, `/bo*\/` matches 'boooo' in "A ghost booooed" and 'b' in "A bird warbled",
+ * |                  | but nothing in "A goat grunted".
+ * |                  |
+ * | `+`              | Matches the preceding item 1 or more times. Equivalent to `{1,}`.
+ * |                  |
+ * |                  | For example, `/a+/` matches the 'a' in "candy" and all the a's in "caaaaaaandy".
+ * |                  |
+ * | `?`              | Matches the preceding item 0 or 1 time.
+ * |                  |
+ * |                  | For example, `/e?le?/` matches the 'el' in "angel" and the 'le' in "angle."
+ * |                  |
+ * |                  | If used immediately after any of the quantifiers `*`, `+`, `?`, or `{}`, makes the quantifier
+ * |                  | non-greedy (matching the minimum number of times), as opposed to the default, which is
+ * |                  | greedy (matching the maximum number of times).
+ * |                  |
+ * |                  | Also used in lookahead assertions, described under `(?=)`, `(?!)`, and `(?:)` in this table.
+ * |                  |
+ * | `.`              | (The decimal point) matches any single character except the newline characters: \n \r
+ * |                  | \u2028 or \u2029. (`[\s\S]` can be used to match any character including new lines.)
+ * |                  |
+ * |                  | For example, `/.n/` matches 'an' and 'on' in "nay, an apple is on the tree", but not 'nay'.
+ * |                  |
+ * | `(x)`            | Matches `x` and remembers the match. These are called capturing parentheses.
+ * |                  |
+ * |                  | For example, `/(foo)/` matches and remembers 'foo' in "foo bar." The matched substring can
+ * |                  | be recalled from the resulting array's elements `[1], ..., [n]` or from the predefined RegExp
+ * |                  | object's properties `$1, ..., $9`.
+ * |                  |
+ * | `(?:x)`          | Matches `x` but does not remember the match. These are called non-capturing parentheses.
+ * |                  | The matched substring can not be recalled from the resulting array's elements `[1], ..., [n]`
+ * |                  | or from the predefined RegExp object's properties `$1, ..., $9`.
+ * |                  |
+ * | `x(?=y)`         | Matches `x` only if `x` is followed by `y`. For example, `/Jack(?=Sprat)/` matches 'Jack' only if
+ * |                  | it is followed by 'Sprat'. `/Jack(?=Sprat|Frost)/` matches 'Jack' only if it is followed by
+ * |                  | 'Sprat' or 'Frost'. However, neither 'Sprat' nor 'Frost' is part of the match results.
+ * |                  |
+ * | `x(?!y)`         | Matches `x` only if `x` is not followed by `y`. For example, `/\d+(?!\.)/` matches a number only
+ * |                  | if it is not followed by a decimal point.
+ * |                  |
+ * |                  | `/\d+(?!\.)/.exec("3.141")` matches 141 but not 3.141.
+ * |                  |
+ * | `x|y`            | Matches either `x` or `y`.
+ * |                  |
+ * |                  | For example, `/green|red/` matches 'green' in "green apple" and 'red' in "red apple."
+ * |                  |
+ * | `{n}`            | Where `n` is a positive integer. Matches exactly n occurrences of the preceding item.
+ * |                  |
+ * |                  | For example, `/a{2}/` doesn't match the 'a' in "candy," but it matches all of the a's
+ * |                  | in "caandy," and the first two a's in "caaandy."
+ * |                  |
+ * | `{n,}`           | Where `n` is a positive integer. Matches at least n occurrences of the preceding item.
+ * |                  |
+ * |                  | For example, `/a{2,}/` doesn't match the 'a' in "candy", but matches all of the a's in
+ * |                  | "caandy" and in "caaaaaaandy."
+ * |                  |
+ * | `{n,m}`          | Where `n` and `m` are positive integers. Matches at least `n` and at most `m` occurrences of the
+ * |                  | preceding item.
+ * |                  |
+ * |                  | For example, `/a{1,3}/` matches nothing in "cndy", the 'a' in "candy," the first two a's
+ * |                  | in "caandy," and the first three a's in "caaaaaaandy". Notice that when matching
+ * |                  | "caaaaaaandy", the match is "aaa", even though the original string had more a's in it.
+ * |                  |
+ * | `[xyz]`          | A character set. Matches any one of the enclosed characters. You can specify a range of
+ * |                  | characters by using a hyphen.
+ * |                  |
+ * |                  | For example, `[abcd]` is the same as `[a-d]`. They match the 'b' in "brisket" and the 'c'
+ * |                  | in "chop".
+ * |                  |
+ * | `[^xyz]`         | A negated or complemented character set. That is, it matches anything that is not
+ * |                  | enclosed in the brackets. You can specify a range of characters by using a hyphen.
+ * |                  |
+ * |                  | For example, `[^abc]` is the same as `[^a-c]`. They initially match 'r' in "brisket" and
+ * |                  | 'h' in "chop."
+ * |                  |
+ * | `[\b]`           | Matches a backspace. (Not to be confused with `\b`.)
+ * |                  |
+ * | `\b`             | Matches a word boundary, such as a space. (Not to be confused with `[\b]`.)
+ * |                  |
+ * |                  | For example, `/\bn\w/` matches the 'no' in "noonday"; `/\wy\b/` matches the 'ly' in
+ * |                  | "possibly yesterday."
+ * |                  |
+ * | `\B`             | Matches a non-word boundary.
+ * |                  |
+ * |                  | For example, `/\w\Bn/` matches 'on' in "noonday", and `/y\B\w/` matches 'ye' in "possibly
+ * |                  | yesterday."
+ * |                  |
+ * | `\cX`            | Where X is a letter from A - Z. Matches a control character in a string.
+ * |                  |
+ * |                  | For example, `/\cM/` matches control-M in a string.
+ * |                  |
+ * | `\d`             | Matches a digit character in the basic Latin alphabet. Equivalent to `[0-9]`.
+ * |                  |
+ * |                  | For example, `/\d/` or `/[0-9]/` matches '2' in "B2 is the suite number."
+ * |                  |
+ * | `\D`             | Matches any non-digit character in the basic Latin alphabet. Equivalent to `[^0-9]`.
+ * |                  |
+ * |                  | For example, `/\D/` or `/[^0-9]/` matches 'B' in "B2 is the suite number.
+ * |                  |
+ * | `\f`             | Matches a form-feed.
+ * |                  |
+ * | `\n`             | Matches a linefeed.
+ * |                  |
+ * | `\r`             | Matches a carriage return.
+ * |                  |
+ * | `\s`             | Matches a single white space character, including space, tab, form feed, line feed and
+ * |                  | other unicode spaces. Equivalent to:
+ * |                  |
+ * |                  | `[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]`
+ * |                  |
+ * |                  | For example, `/\s\w*\/` matches ' bar' in "foo bar."
+ * |                  |
+ * | `\S`             | Matches a single character other than white space. Equivalent to:
+ * |                  |
+ * |                  | `[^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]`
+ * |                  |
+ * |                  | For example, `/\S\w*\/` matches 'foo' in "foo bar."
+ * |                  |
+ * | `\t`             | Matches a tab.
+ * |                  |
+ * | `\v`             | Matches a vertical tab.
+ * |                  |
+ * | `\w`             | Matches any alphanumeric character from the basic Latin alphabet, including the
+ * |                  | underscore. Equivalent to `[A-Za-z0-9_]`.
+ * |                  |
+ * |                  | For example, `/\w/` matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."
+ * |                  |
+ * | `\W`             | Matches any character that is not a word character from the basic Latin alphabet. Equivalent
+ * |                  | to `[^A-Za-z0-9_]`.
+ * |                  |
+ * |                  | For example, `/\W/` or `/[^A-Za-z0-9_]/` matches '%' in "50%."
+ * |                  |
+ * | `\n`             | Where `n` is a positive integer. A back reference to the last substring matching the n
+ * |                  | parenthetical in the regular expression (counting left parentheses).
+ * |                  |
+ * |                  | For example, `/apple(,)\sorange\1/` matches 'apple, orange,' in "apple, orange, cherry,
+ * |                  | peach." A more complete example follows this table.
+ * |                  |
+ * | `\0`             | Matches a NULL character. Do not follow this with another digit.
+ * |                  |
+ * | `\xhh`           | Matches the character with the code `hh` (two hexadecimal digits)
+ * |                  |
+ * | `\uhhhh`         | Matches the character with the Unicode value `hhhh` (four hexadecimal digits)
+ *
+ * The literal notation provides compilation of the regular expression when the expression is evaluated. Use
+ * literal notation when the regular expression will remain constant. For example, if you use literal notation
+ * to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.
+ *
+ * The constructor of the regular expression object, for example, new RegExp("ab+c"), provides runtime
+ * compilation of the regular expression. Use the constructor function when you know the regular expression
+ * pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.
+ *
+ * <div class="notice">
+ * Documentation for this class comes from <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/RegExp">MDN</a>
+ * and is available under <a href="http://creativecommons.org/licenses/by-sa/2.0/">Creative Commons: Attribution-Sharealike license</a>.
+ * </div>
+ */
+
+/**
+ * @method constructor
+ * Creates new regular expression object.
+ *
+ * @param {String} pattern
+ * The text of the regular expression.
+ * @param {String} flags
+ * If specified, flags can have any combination of the following values:
+ *
+ * - "g" - global match
+ * - "i" - ignore case
+ * - "m" - Treat beginning and end characters (^ and $) as working over multiple lines
+ *   (i.e., match the beginning or end of _each_ line (delimited by \n or \r), not
+ *   only the very beginning or end of the whole input string)
+ */
+
+//Methods
+
+/**
+ * @method exec
+ * Executes a search for a match in its string parameter.
+ *
+ * If the match succeeds, the `exec` method returns an array and updates properties of the regular
+ * expression object. The returned array has the matched text as the first item, and then one item for
+ * each capturing parenthesis that matched containing the text that was captured.  If the match fails,
+ * the `exec` method returns `null`.
+ *
+ * If you are executing a match simply to find true or false, use the `test` method or the `String
+ * search` method.
+ *
+ * Consider the following example:
+ *
+ *     // Match one d followed by one or more b's followed by one d
+ *     // Remember matched b's and the following d
+ *     // Ignore case
+ *     var re = /d(b+)(d)/ig;
+ *     var result = re.exec("cdbBdbsbz");
+ *
+ * The following table shows the results for this script:
+ *
+ * | Object           | Property/Index | Description                                                          | Example
+ * |:-----------------|:---------------|:---------------------------------------------------------------------|:---------------------
+ * | `result`         |                | The content of myArray.                                              | `["dbBd", "bB", "d"]`
+ * |                  | `index`        | The 0-based index of the match in the string                         | `1`
+ * |                  | `input`        | The original string.                                                 | `cdbDdbsbz`
+ * |                  | `[0]`          | The last matched characters.                                         | `dbBd`
+ * |                  | `[1], ...[n]`  | The parenthesized substring matches, if any. The number of possible  | `[1] = bB`
+ * |                  |                | parenthesized substrings is unlimited.                               | `[2] = d`
+ * | `re`             | `lastIndex`    | The index at which to start the next match.                          | `5`
+ * |                  | `ignoreCase`   | Indicates the "`i`" flag was used to ignore case.                    | `true`
+ * |                  | `global`       | Indicates the "`g`" flag was used for a global match.                | `true`
+ * |                  | `multiline`    | Indicates the "`m`" flag was used to search in strings across        | `false`
+ * |                  |                | multiple lines.                                                      |
+ * |                  | `source`       | The text of the pattern.                                             | d(b+)(d)
+ *
+ * If your regular expression uses the "`g`" flag, you can use the `exec` method multiple times to find
+ * successive matches in the same string. When you do so, the search starts at the substring of `str`
+ * specified by the regular expression's `lastIndex` property (`test` will also advance the `lastIndex`
+ * property). For example, assume you have this script:
+ *
+ *     var myRe = /ab*\/g;
+ *     var str = "abbcdefabh";
+ *     var myArray;
+ *     while ((myArray = myRe.exec(str)) != null)
+ *     {
+ *         var msg = "Found " + myArray[0] + ".  ";
+ *         msg += "Next match starts at " + myRe.lastIndex;
+ *     print(msg);
+ *     }
+ *
+ * This script displays the following text:
+ *
+ *     Found abb. Next match starts at 3
+ *     Found ab. Next match starts at 9
+ *
+ * You can also use `exec()` without creating a RegExp object:
+ *
+ *     var matches = /(hello \S+)/.exec('This is a hello world!');
+ *     alert(matches[1]);
+ *
+ * This will display an alert containing 'hello world!';
+ *
+ * @param {String} str The string against which to match the regular expression.
+ * @return {Array} Array of results or `NULL`.
+ */
+
+/**
+ * @method test
+ * Tests for a match in its string parameter.
+ *
+ * When you want to know whether a pattern is found in a string use the test method (similar to the
+ * `String.search` method); for more information (but slower execution) use the exec method (similar to
+ * the `String.match` method). As with exec (or in combination with it), test called multiple times on
+ * the same global regular expression instance will advance past the previous match.
+ *
+ * The following example prints a message which depends on the success of the test:
+ *
+ *     function testinput(re, str){
+ *         if (re.test(str))
+ *             midstring = " contains ";
+ *         else
+ *             midstring = " does not contain ";
+ *         document.write (str + midstring + re.source);
+ *     }
+ *
+ * @param {String} str The string against which to match the regular expression.
+ * @return {Boolean} true if string contains any matches, otherwise returns false.
+ */
+
+/**
+ * @method toString
+ * Returns a string representing the specified object. Overrides the `Object.prototype.toString`
+ * method.
+ *
+ * The RegExp object overrides the `toString` method of the `Object` object; it does not inherit
+ * `Object.toString`. For RegExp objects, the `toString` method returns a string representation of the
+ * regular expression.
+ *
+ * The following example displays the string value of a RegExp object:
+ *
+ *     myExp = new RegExp("a+b+c");
+ *     alert(myExp.toString());       // displays "/a+b+c/"
+ *
+ * @return {String} Regular expression as a string.
+ */
+
+//Properties
+
+// Note that several of the RegExp properties have both long and short (Perl-like) names.
+// Both names always refer to the same value. Perl is the programming language from which
+// JavaScript modeled its regular expressions.
+
+/**
+ * @property {Boolean} global
+ * Whether to test the regular expression against all possible matches in a
+ * string, or only against the first.
+ *
+ * `global` is a property of an individual regular expression object.
+ *
+ * The value of `global` is true if the "`g`" flag was used; otherwise, `false`. The "`g`" flag
+ * indicates that the regular expression should be tested against all possible matches in a string.
+ *
+ * You cannot change this property directly.
+ */
+
+/**
+ * @property {Boolean} ignoreCase
+ * Whether to ignore case while attempting a match in a string.
+ *
+ * `ignoreCase` is a property of an individual regular expression object.
+ *
+ * The value of `ignoreCase` is true if the "`i`" flag was used; otherwise, false. The "`i`" flag indicates
+ * that case should be ignored while attempting a match in a string.
+ *
+ * You cannot change this property directly.
+ */
+
+/**
+ * @property {Number} lastIndex
+ * The index at which to start the next match. A read/write integer property that specifies the index
+ * at which to start the next match.
+ *
+ * `lastIndex` is a property of an individual regular expression object.
+ *
+ * This property is set only if the regular expression used the "`g`" flag to indicate a global search.
+ * The following rules apply:
+ *
+ * -   If `lastIndex` is greater than the length of the string, `regexp.test` and `regexp.exec` fail,
+ *     and `lastIndex` is set to 0.
+ * -   If `lastIndex` is equal to the length of the string and if the regular expression matches the
+ *     empty string, then the regular expression matches input starting at `lastIndex`.
+ * -   If `lastIndex` is equal to the length of the string and if the regular expression does not match
+ *     the empty string, then the regular expression mismatches input, and `lastIndex` is reset to 0.
+ * -   Otherwise, `lastIndex` is set to the next position following the most recent match.
+ *
+ * For example, consider the following sequence of statements:
+ *
+ * -   `re = /(hi)?/g` Matches the empty string.
+ * -   `re("hi")` Returns `["hi", "hi"]` with `lastIndex` equal to 2.
+ * -   `re("hi")` Returns `[""]`, an empty array whose zeroth element is the match string. In this
+ *     case, the empty string because `lastIndex` was 2 (and still is 2) and "`hi`" has length 2.
+ */
+
+/**
+ * @property {Boolean} multiline
+ * Whether or not to search in strings across multiple lines.
+ *
+ * `multiline` is a property of an individual regular expression object..
+ *
+ * The value of `multiline` is true if the "`m`" flag was used; otherwise, `false`. The "`m`" flag
+ * indicates that a multiline input string should be treated as multiple lines. For example, if "`m`"
+ * is used, "`^`" and "`$`" change from matching at only the start or end of the entire string to the
+ * start or end of any line within the string.
+ *
+ * You cannot change this property directly.
+ */
+
+/**
+ * @property {String} source
+ * The text of the pattern.
+ *
+ * A read-only property that contains the text of the pattern, excluding the forward slashes.
+ *
+ * `source` is a property of an individual regular expression object.
+ *
+ * You cannot change this property directly.
+ */