diff --git a/notNeededPackages.json b/notNeededPackages.json
index 88ce062809..67cda351a3 100644
--- a/notNeededPackages.json
+++ b/notNeededPackages.json
@@ -196,6 +196,12 @@
             "typingsPackageName": "upper-case-first",
             "sourceRepoUrl": "https://github.com/blakeembrey/upper-case-first",
             "asOfVersion": "1.1.2"
+        },
+        {
+            "libraryName": "Sugar",
+            "typingsPackageName": "sugar",
+            "sourceRepoURL": "https://github.com/andrewplummer/Sugar",
+            "asOfVersion": "2.0.2"
         }
     ]
 }
diff --git a/sugar/index.d.ts b/sugar/index.d.ts
deleted file mode 100644
index 8a5b9f645a..0000000000
--- a/sugar/index.d.ts
+++ /dev/null
@@ -1,5025 +0,0 @@
-// Type definitions for Sugar 1.3.9
-// Project: http://sugarjs.com/
-// Definitions by: Josh Baldwin <https://github.com/jbaldwin/>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-/*
-sugar-1.3.9.d.ts may be freely distributed under the MIT license.
-
-Copyright (c) 2013 Josh Baldwin https://github.com/jbaldwin/sugar.d.ts
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-interface String {
-
-	/**
-	* Adds <str> at [index].<br/> Negative values are also allowed.
-	* @param str String to add.
-	* @param index Index where <str> is added. Default = str.length
-	* @returns Original string with <str> added at [index].
-	* @extra %insert% is provided as an alias, and is generally more readable when using an index.
-	* @example
-	*   'schfifty'.add(' five')         -> schfifty five
-	*   'dopamine'.insert('e', 3)       -> dopeamine
-	*   'spelling eror'.insert('r', -3) -> spelling error
-	**/
-	add(str: string, index?: number): string;
-
-	/**
-	* @see add
-	**/
-	insert(str: string, index?: number): string;
-
-	/**
-	* Assigns variables to tokens in a string.
-	* @param objs Variable tokens to assign in the string.
-	* @returns String with <objs> assigned to variables in the original string.
-	* @extra If an object is passed, it's properties can be assigned using
-	*        the object's keys. If a non-object (string, number, etc.)
-	*        is passed it can be accessed by the argument number beginning
-	*        with 1 (as with regex tokens). Multiple objects can be passed
-	*        and will be merged together (original objects are unaffected).
-	* @example
-	*   'Welcome, Mr. {name}.'.assign({ name: 'Franklin' })   -> 'Welcome, Mr. Franklin.'
-	*   'You are {1} years old today.'.assign(14)             -> 'You are 14 years old today.'
-	*   '{n} and {r}'.assign({ n: 'Cheech' }, { r: 'Chong' }) -> 'Cheech and Chong'
-	**/
-	assign(...objs: any[]): string;
-
-	/***
-	* Gets the character(s) at a given index.
-	* @param index Indicies of the character(s) requested.
-	* @param loop Loop around the string or stop at the end, default = true.
-	* @returns Character(s) at the specified indices.
-	* @extra When [loop] is true, overshooting the end of the string
-	*        (or the beginning) will begin counting from the other end.
-	*        As an alternate syntax, passing multiple indexes will get
-	*        the characters at those indexes.
-	* @example
-	*   'jumpy'.at(0)               -> 'j'
-	*   'jumpy'.at(2)               -> 'm'
-	*   'jumpy'.at(5)               -> 'j'
-	*   'jumpy'.at(5, false)        -> ''
-	*   'jumpy'.at(-1)              -> 'y'
-	*   'lucky charms'.at(2,4,6,8) -> ['u','k','y',c']
-	***/
-	at(index: number, loop?: boolean): string;
-
-	/**
-	* @see at
-	* @limitation Typescript does not allow for arguments after a variable argument list.
-	**/
-	at(...indicies: number[]): string[];
-
-	/**
-	* Converts underscores and hyphens to camel case.
-	* @param first If [first] is true the first letter will also be capitalized, default = true
-	* @returns Camel case version of the string.
-	* @extra If the Inflections package is included acryonyms can also
-	*        be defined that will be used when camelizing.
-	* @example
-	*   'caps_lock'.camelize()              -> 'CapsLock'
-	*   'moz-border-radius'.camelize()      -> 'MozBorderRadius'
-	*   'moz-border-radius'.camelize(false) -> 'mozBorderRadius'
-	**/
-	camelize(first?: boolean): string;
-
-	/**
-	* Capitalizes the first character in the string.
-	* @method capitalize([all] = false)
-	* @param all Default = false
-	* @returns String
-	* @extra If [all] is true, all words in the string will be capitalized.
-	* @example
-	*
-	*   'hello'.capitalize()           -> 'Hello'
-	*   'hello kitty'.capitalize()     -> 'Hello kitty'
-	*   'hello kitty'.capitalize(true) -> 'Hello Kitty'
-	*
-	**/
-	capitalize(all?: boolean): string;
-
-	/**
-	* Runs callback [fn] against each character in the string.
-	* Returns an array of characters.
-	* @param fn Callback function for each character in the string.
-	* @returns string[] with each element containing one character
-	*          in the string.
-	* @example
-	*   'jumpy'.chars() -> ['j','u','m','p','y']
-	*   'jumpy'.chars(function(c) {
-	*     // Called 5 times: "j","u","m","p","y"
-	*   });
-	**/
-	chars(fn?: (c: string) => void ): string[];
-
-	/**
-	* Runs callback [fn] against each character code in the string.
-	  Returns an array of character codes.
-	* @param fn Callback function for each character code in the string.
-	* @returns number[] with each element containing one character code
-	*          in the string.
-	* @example
-	*   'jumpy'.codes() -> [106,117,109,112,121]
-	*   'jumpy'.codes(function(c) {
-	*     // Called 5 times: 106, 117, 109, 112, 121
-	*   });
-	***/
-	codes(fn?: (c: string) => void ): number[];
-
-	/**
-	* Compacts all white space in the string to a single space and trims the ends.
-	* @returns String with all whitespace compated to a single space.
-	* @example
-	*   'too \n much \n space'.compact() -> 'too much space'
-	*   'enough \n '.compact()           -> 'enough'
-	**/
-	compact(): string;
-
-	/**
-	* Converts underscores and camel casing to hypens.
-	* @returns String with underscores and camel casing changed to hypens.
-	* @example
-	*   'a_farewell_to_arms'.dasherize() -> 'a-farewell-to-arms'
-	*   'capsLock'.dasherize()           -> 'caps-lock'
-	**/
-	dasherize(): string;
-
-	/**
-	* Decodes the string from base64 encoding.
-	* @returns Decoded base64 string.
-	* @extra This method wraps the browser native %atob% when available,
-	*        and uses a custom implementation when not available.
-	* @example
-	*   'aHR0cDovL3R3aXR0ZXIuY29tLw=='.decodeBase64() -> 'http://twitter.com/'
-	*   'anVzdCBnb3QgZGVjb2RlZA=='.decodeBase64()     -> 'just got decoded!'
-	**/
-	decodeBase64(): string;
-
-	/**
-	* Runs callback [fn] against each occurence of [search].
-	* @param fn Callback function for each occurance of [search].
-	*           If [search] is not provided each character is matched.
-	* @param search Search item to look for in the string.
-	* @returns string[] of each item matched in the string.
-	* @extra Returns an array of matches. [search] may be either
-	*        a string or regex, and defaults to every character in the string.
-	* @example
-	*   'jumpy'.each() -> ['j','u','m','p','y']
-	*   'jumpy'.each(/[r-z]/) -> ['u','y']
-	*   'jumpy'.each(/[r-z]/, function(m) {
-	*     // Called twice: "u", "y"
-	*   });
-	**/
-	each(search: string, fn?: (m: string) => void): string[];
-
-	/**
-	* @see each
-	**/
-	each(search: RegExp, fn?: (m: string) => void): string[];
-
-	/**
-	* @see each
-	**/
-	each(fn?: (m: string) => void ): string[];
-
-	/**
-	* Encodes the string into base64 encoding.
-	* @returns Base64 encoded string.
-	* @extra This method wraps the browser native %btoa% when available,
-	*        and uses a custom implementation when not available.
-	* @example
-	*   'gonna get encoded!'.encodeBase64()  -> 'Z29ubmEgZ2V0IGVuY29kZWQh'
-	*   'http://twitter.com/'.encodeBase64() -> 'aHR0cDovL3R3aXR0ZXIuY29tLw=='
-	**/
-	encodeBase64(): string;
-
-	/**
-	* Returns true if the string ends with <find>.
-	* @param find String or RegExp to find at the end of the string.
-	* @param pos Ending position to search for, defaults to the end of the string.
-	* @param case_ True for case sensitive, default = true.
-	* @returns True if the string ends with <find>.
-	* @example
-	*   'jumpy'.endsWith('py')         -> true
-	*   'jumpy'.endsWith(/[q-z]/)      -> true
-	*   'jumpy'.endsWith('MPY')        -> false
-	*   'jumpy'.endsWith('MPY', false) -> true
-	**/
-	endsWith(find: string, pos?: number, case_?: boolean): boolean;
-
-	/**
-	* @see endsWith
-	**/
-	endsWith(find: string, case_?: boolean): boolean;
-
-	/**
-	* @see endsWith
-	**/
-	endsWith(find: RegExp, pos?: number, case_?: boolean): boolean;
-
-	/**
-	* @see endsWith
-	**/
-	endsWith(find: RegExp, case_?: boolean): boolean;
-
-	/**
-	* Converts HTML characters to their entity equivalents.
-	* @returns HTML escaped string.
-	* @example
-	*   '<p>some text</p>'.escapeHTML() -> '&lt;p&gt;some text&lt;/p&gt;'
-	*   'one & two'.escapeHTML()        -> 'one &amp; two'
-	**/
-	escapeHTML(): string;
-
-	/**
-	* Escapes all RegExp tokens in the string.
-	* @returns RegExp escaped string.
-	* @example
-	*   'really?'.escapeRegExp()       -> 'really\?'
-	*   'yes.'.escapeRegExp()         -> 'yes\.'
-	*   '(not really)'.escapeRegExp() -> '\(not really\)'
-	**/
-	escapeRegExp(): string;
-
-	/**
-	* Escapes characters in a string to make a valid URL.
-	* @returns URL escaped string.
-	* @extra If [param] is true, it will also escape valid URL
-	*        characters for use as a URL parameter.
-	* @example
-	*   'http://foo.com/"bar"'.escapeURL()     -> 'http://foo.com/%22bar%22'
-	*   'http://foo.com/"bar"'.escapeURL(true) -> 'http%3A%2F%2Ffoo.com%2F%22bar%22'
-	**/
-	escapeURL(param?: boolean): string;
-
-	/**
-	* Returns the first [n] characters of the string.
-	* @returns String
-	* @example
-	*   'lucky charms'.first()   -> 'l'
-	*   'lucky charms'.first(3)  -> 'luc'
-	**/
-	first(n?: number): string;
-
-	/**
-	* Returns a section of the string starting from [index].
-	* @returns String
-	* @example
-	*   'lucky charms'.from()   -> 'lucky charms'
-	*   'lucky charms'.from(7)  -> 'harms'
-	**/
-	from(index?: number): string;
-
-	/**
-	* Converts full-width characters (zenkaku) to half-width (hankaku).
-	* @param mode default = 'all'
-	* @returns Converted string to hankaku.
-	* @extra [mode] accepts any combination of
-	*        "a" (alphabet),
-	*        "n" (numbers),
-	*        "k" (katakana),
-	*        "s" (spaces),
-	*        "p" (punctuation),
-	*        or "all".
-	* @example
-	*   '??? YAMADA??!'.hankaku()                      -> '??? YAMADA??!'
-	*   '??? YAMADA??!'.hankaku('a')                   -> '??? YAMADA??!'
-	*   '??? YAMADA??!'.hankaku('alphabet')            -> '??? YAMADA??!'
-	*   '?????! 25???!'.hankaku('katakana', 'numbers') -> '?????! 25???!'
-	*   '?????! 25???!'.hankaku('k', 'n')              -> '?????! 25???!'
-	*   '?????! 25???!'.hankaku('kn')                  -> '?????! 25???!'
-	*   '?????! 25???!'.hankaku('sp')                  -> '?????! 25???!'
-	**/
-	hankaku(mode?: string): string;
-
-	/**
-	* @see hankaku
-	**/
-	hankaku(...modes: string[]): string;
-
-	/**
-	* Returns true if the string matches <find>.
-	* @param find Search parameters.
-	* @returns True if the string matchs <find>, otherwise false.
-	* @example
-	*   'jumpy'.has('py')     -> true
-	*   'broken'.has(/[a-n]/) -> true
-	*   'broken'.has(/[s-z]/) -> false
-	**/
-	has(find: string): boolean;
-
-	/**
-	* @see has
-	**/
-	has(find: RegExp): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Arabic.
-	* @returns True if the string contains Arabic.
-	* @example
-	*   '?????'.hasArabic()          -> true
-	*   '?????'.hasCyrillic()        -> true
-	*   '? ?????!'.hasHangul() -> true
-	*   '??????'.hasKatakana() -> true
-	*   "l'année".hasLatin()         -> true
-	**/
-	hasArabic(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Cyrillic.
-	* @returns True if the string contains Cyrillic.
-	**/
-	hasCyrillic(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Greek.
-	* @returns True if the string contains Greek.
-	**/
-	hasGreek(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Hangul.
-	* @returns True if the string contains Hangul.
-	**/
-	hasHangul(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Han.
-	* @returns True if the string contains Han.
-	**/
-	hasHan(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Kanji.
-	* @returns True if the string contains Kanji.
-	**/
-	hasKanji(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Hebrew.
-	* @returns True if the string contains Hebrew.
-	**/
-	hasHebrew(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Hiragana.
-	* @returns True if the string contains Hiragana.
-	**/
-	hasHiragana(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Kana.
-	* @returns True if the string contains Kana.
-	**/
-	hasKana(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Katakana.
-	* @returns True if the string contains Katakana.
-	**/
-	hasKatakana(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Latin.
-	* @returns True if the string contains Latin.
-	**/
-	hasLatin(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Thai.
-	* @returns True if the string contains Thai.
-	**/
-	hasThai(): boolean;
-
-	/**
-	* Returns true if the string contains any characters in Devanagari.
-	* @returns True if the string contains Devanagari.
-	**/
-	hasDevanagari(): boolean;
-
-	/**
-	* Converts katakana into hiragana.
-	* @param all If [all] is false, only full-width katakana will be converted, default = true.
-	* @returns Converted string to hiragana.
-	* @example
-	*   '????'.hiragana()   -> '????'
-	*   '?????'.hiragana() -> '?????'
-	*   '????'.hiragana()       -> '????'
-	*   '????'.hiragana(false)  -> '????'
-	**/
-	hiragana(all?: boolean): string;
-
-	/**
-	* Creates a human readable string.
-	* @returns Pretty printed version of the string.
-	* @extra Capitalizes the first word and turns underscores into spaces and strips a
-	*        trailing '_id', if any. Like String#titleize, this is meant for creating pretty output.
-	* @example
-	*   'employee_salary'.humanize() -> 'Employee salary'
-	*   'author_id'.humanize()       -> 'Author'
-	**/
-	humanize(): string;
-
-	/**
-	* Returns true if the string has a length of 0 or contains only whitespace.
-	* @returns True if the string has a length of 0 or contains only whitespace.
-	* @example
-	*   ''.isBlank()      -> true
-	*   '   '.isBlank()   -> true
-	*   'noway'.isBlank() -> false
-	**/
-	isBlank(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Arabic. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Arabic.
-	* @example
-	*   '?????'.isArabic()          -> true
-	*   '?????'.isCyrillic()        -> true
-	*   '? ?????!'.isHangul() -> true
-	*   '??????'.isKatakana() -> false
-	*   "l'année".isLatin()         -> true
-	**/
-	isArabic(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Cyrillic. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Cyrillic.
-	**/
-	isCyrillic(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Greek. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Greek.
-	**/
-	isGreek(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Hangul. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Hangul.
-	**/
-	isHangul(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Han. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Han.
-	**/
-	isHan(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Kanji. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Kanji.
-	**/
-	isKanji(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Hebrew. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Hebrew.
-	**/
-	isHebrew(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Hiragana. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Hiragana.
-	**/
-	isHiragana(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Kana. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Kana.
-	**/
-	isKana(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Katakana. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Katakana.
-	**/
-	isKatakana(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Latin. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Latin.
-	**/
-	isLatin(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Thai. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Thai.
-	**/
-	isThai(): boolean;
-
-	/**
-	* Returns true if the string contains only characters in Devanagari. Whitespace is ignored.
-	* @returns True if the string containsly only characters in Devanagari.
-	**/
-	isDevanagari(): boolean;
-
-	/**
-	* Converts hiragana into katakana.
-	* @returns Converted string to katakana.
-	* @example
-	*   '????'.katakana()   -> '????'
-	*   '?????'.katakana() -> '?????'
-	**/
-	katakana(): string;
-
-	/**
-	* Returns the last [n] characters of the string.
-	* @param last Default = 1.
-	* @returns The last [n] characters of the string.
-	* @example
-	*   'lucky charms'.last()   -> 's'
-	*   'lucky charms'.last(3)  -> 'rms'
-	**/
-	last(n?: number): string;
-
-	/**
-	* Runs callback [fn] against each line in the string.
-	* @param fn Callback against each line in the original string.
-	* @returns A string[] where each element is a line in the original string.
-	* @example
-	*   'broken wear\nand\njumpy jump'.lines() -> ['broken wear','and','jumpy jump']
-	*   'broken wear\nand\njumpy jump'.lines(function(l) {
-	*     // Called three times: "broken wear", "and", "jumpy jump"
-	*   });
-	**/
-	lines(fn?: (l: string) => void): string[];
-
-	/**
-	* Returns the string with accented and non-standard Latin-based
-	* characters converted into ASCII approximate equivalents.
-	* @returns String
-	* @example
-	*   'á'.normalize()                  -> 'a'
-	*   'Ménage à trois'.normalize()     -> 'Menage a trois'
-	*   'Volkswagen'.normalize()         -> 'Volkswagen'
-	*   'FULLWIDTH'.normalize() -> 'FULLWIDTH'
-	**/
-	normalize(): string;
-
-	/**
-	* Pads either/both sides of the string.
-	* @param padding The padding characters to add to the string.
-	* @param num The number of <padding> to add to the string, default = 1.
-	* @returns String
-	* @extra [num] is the number of characters on each side,
-	*        and [padding] is the character to pad with.
-	* @example
-	*   'wasabi'.pad('-')         -> '-wasabi-'
-	*   'wasabi'.pad('-', 2)      -> '--wasabi--'
-	*   'wasabi'.padLeft('-', 2)  -> '--wasabi'
-	*   'wasabi'.padRight('-', 2) -> 'wasabi--'
-	**/
-	pad(padding: string, num?: number): string;
-
-	/**
-	* @see pad
-	**/
-	padLeft(padding: string, num?: number): string;
-
-	/**
-	* @see pad
-	**/
-	padRight(padding: string, num?: number): string;
-
-	/**
-	* Runs callback [fn] against each paragraph in the string.
-	* @param fn Callback function called for each paragraph in the string.
-	* @returns Returns a string[] where each element is a paragraph in the original string.
-	* @extra A paragraph here is defined as a block of text bounded
-	*        by two or more line breaks.
-	* @example
-	*   'Once upon a time.\n\nIn the land of oz...'.paragraphs() -> ['Once upon a time.','In the land of oz...']
-	*   'Once upon a time.\n\nIn the land of oz...'.paragraphs(function(p) {
-	*     // Called twice: "Once upon a time.", "In teh land of oz..."
-	*   });
-	**/
-	paragraphs(fn?: (p: string) => void): string[];
-
-	/**
-	* Replaces special characters in a string so that it may be used as part of a pretty URL.
-	* @returns URL parameterizes the string.
-	* @example
-	*   'hell, no!'.parameterize() -> 'hell-no'
-	**/
-	parameterize(): string;
-
-	/**
-	* Returns the plural form of the word in the string.
-	* @method pluralize()
-	* @returns String
-	* @example
-	*   'post'.pluralize()         -> 'posts'
-	*   'octopus'.pluralize()      -> 'octopi'
-	*   'sheep'.pluralize()        -> 'sheep'
-	*   'words'.pluralize()        -> 'words'
-	*   'CamelOctopus'.pluralize() -> 'CamelOctopi'
-	**/
-	pluralize(): string;
-
-	/**
-	* Removes any part of the string that matches <find>.
-	* @param find Remove this from the string.
-	* @returns String with all instances of <find> removed.
-	* @extra <find> can be a string or a regex.
-	* @example
-	*   'schfifty five'.remove('f')     -> 'schity ive'
-	*   'schfifty five'.remove(/[a-f]/g) -> 'shity iv'
-	**/
-	remove(find: string): string;
-
-	/**
-	* @see remove
-	**/
-	remove(find: RegExp): string;
-
-	/**
-	* Removes all HTML tags and their contents from the string
-	* @param tags Remove these HTML tags.
-	* @returns String with HTML tags removed.
-	* @extra Tags to remove may be enumerated in the parameters, otherwise will remove all.
-	* @example
-	*   '<p>just <b>some</b> text</p>'.removeTags()    -> ''
-	*   '<p>just <b>some</b> text</p>'.removeTags('b') -> '<p>just text</p>'
-	**/
-	removeTags(...tags: string[]): string;
-
-	/**
-	* Returns the string repeated [num] times.
-	* @param num Number of times to repeat the string, default = 0.
-	* @returns Repeated [num] string.
-	* @example
-	*   'jumpy'.repeat(2) -> 'jumpyjumpy'
-	*   'a'.repeat(5)     -> 'aaaaa'
-	*   'a'.repeat(0)     -> ''
-	**/
-	repeat(num?: number): string;
-
-	/**
-	* Reverses the string.
-	* @returns Reversed string.
-	* @example
-	*   'jumpy'.reverse()        -> 'ypmuj'
-	*   'lucky charms'.reverse() -> 'smrahc ykcul'
-	**/
-	reverse(): string;
-
-	/**
-	* Shifts each character in the string <num> places in the character map.
-	* @param num Number of characters to shift in the character map.
-	* @returns String with characters shifted <num>.
-	* @example
-	*   'a'.shift(1)  -> 'b'
-	*   '?'.shift(1) -> '?'
-	**/
-	shift(num: number): string[];
-
-	/**
-	* The reverse of String#pluralize.
-	* @returns Returns the singular form of a word in a string.
-	* @example
-	*   'posts'.singularize()       -> 'post'
-	*   'octopi'.singularize()      -> 'octopus'
-	*   'sheep'.singularize()       -> 'sheep'
-	*   'word'.singularize()        -> 'word'
-	*   'CamelOctopi'.singularize() -> 'CamelOctopus'
-	**/
-	singularize(): string;
-
-	/**
-	* Converts camel case, underscores, and hyphens to a properly spaced string.
-	* @returns String
-	* @example
-	*   'camelCase'.spacify()                         -> 'camel case'
-	*   'an-ugly-string'.spacify()                    -> 'an ugly string'
-	*   'oh-no_youDid-not'.spacify().capitalize(true) -> 'something else'
-	**/
-	spacify(): string;
-
-	/**
-	* Returns true if the string starts with <find>.
-	* @param find String or RegExp to look for at the beginning of the string.
-	* @param pos Starting position to start searching, default = 0.
-	* @param case_ True for case sensitive, default = true.
-	* @returns True if the string starts with `find`.
-	* @example
-	*   'hello'.startsWith('hell')        -> true
-	*   'hello'.startsWith(/[a-h]/)       -> true
-	*   'hello'.startsWith('HELL')        -> false
-	*   'hello'.startsWith('HELL', false) -> true
-	**/
-	startsWith(find: string, pos?: number, case_?: boolean): boolean;
-
-	/**
-	* @see startsWith
-	**/
-	startsWith(find: string, case_?: boolean): boolean;
-
-	/**
-	* @see startsWith
-	**/
-	startsWith(find: RegExp, pos?: number, case_?: boolean): boolean;
-
-	/**
-	* @see startsWith
-	**/
-	startsWith(find: RegExp, case_?: boolean): boolean;
-
-	/**
-	* Strips all HTML tags from the string.
-	* @param tags HTML tags to strip from the string.
-	* @returns Returns the string with all HTML removed.
-	* @extra Tags to strip may be enumerated in the parameters, otherwise will strip all.
-	* @example
-	*   '<p>just <b>some</b> text</p>'.stripTags()    -> 'just some text'
-	*   '<p>just <b>some</b> text</p>'.stripTags('p') -> 'just <b>some</b> text'
-	**/
-	stripTags(...tags: string[]): string;
-
-	/**
-	* Creates a title version of the string.
-	* @returns Returns a titlized version of the string.
-	* @extra Capitalizes all the words and replaces some characters
-	*        in the string to create a nicer looking title.
-	*        String#titleize is meant for creating pretty output.
-	* @example
-	*   'man from the boondocks'.titleize() -> 'Man from the Boondocks'
-	*   'x-men: the last stand'.titleize() -> 'X Men: The Last Stand'
-	*   'TheManWithoutAPast'.titleize() -> 'The Man Without a Past'
-	*   'raiders_of_the_lost_ark'.titleize() -> 'Raiders of the Lost Ark'
-	**/
-	titleize(): string;
-
-	/**
-	* Returns a section of the string ending at [index].
-	* @param index Ending position in the substring, default = string.length.
-	* @returns Substring ending at [index].
-	* @example
-	*   'lucky charms'.to()   -> 'lucky charms'
-	*   'lucky charms'.to(7)  -> 'lucky ch'
-	**/
-	to(index?: number): string;
-
-	/**
-	* Converts the string into a number in base [base].
-	* @param base The base to parse the number in, default = 10.
-	* @returns Parsed number.
-	* @extra Any value with a "." fill be converted to a floating point value,
-	*        otherwise an integer.
-	* @example
-	*   '153'.toNumber()    -> 153
-	*   '12,000'.toNumber() -> 12000
-	*   '10px'.toNumber()   -> 10
-	*   'ff'.toNumber(16)   -> 255
-	**/
-	toNumber(base?: number): number;
-
-	/**
-	* Removes leading and/or trailing whitespace from the string.
-	* @returns Returns a string with leading and trailing whitespace removed.
-	* @extra Whitespace is defined as line breaks, tabs, and any character
-	*        in the "Space, Separator" Unicode category, conforming to the
-	*        the ES5 spec. The standard %trim% method is only added when
-	*        not fully supported natively.
-	* @example
-	*   '   wasabi   '.trim()      -> 'wasabi'
-	*   '   wasabi   '.trimLeft()  -> 'wasabi   '
-	*   '   wasabi   '.trimRight() -> '   wasabi'
-	**/
-	// Trim is already available on lib.d.ts interface definition.
-	//trim(): string;
-
-	/**
-	* Removes leading whitespace from the string.
-	* @see trim
-	* @return Returns a string with leading whitespace removed.
-	**/
-	trimLeft(): string;
-
-	/**
-	* Removes trailing whitespace from the string.
-	* @see trim
-	* @return Returns a string with trailing whitespace removed.
-	**/
-	trimRight(): string;
-
-	/**
-	* Truncates a string.
-	* @param length The length to keep in the string before truncating.
-	* @param split True to split words, false keeps them intact but may truncate earlier.
-	* @param from Where to truncate the string from, default = 'right'.
-	* @param ellipsis Character to use as ellipsis.
-	* @returns Truncated string.
-	* @extra If [split] is %false%, will not split words up, and instead
-	*        discard the word where the truncation occurred. [from] can
-	*        also be %"middle"% or %"left"%.
-	* @example
-	*   'just sittin on the dock of the bay'.truncate(20)                 -> 'just sittin on the do...'
-	*   'just sittin on the dock of the bay'.truncate(20, false)          -> 'just sittin on the...'
-	*   'just sittin on the dock of the bay'.truncate(20, true, 'middle') -> 'just sitt...of the bay'
-	*   'just sittin on the dock of the bay'.truncate(20, true, 'left')   -> '...the dock of the bay'
-	**/
-	truncate(length: number, split?: boolean, from?: string, ellipsis?: string): string;
-
-	/**
-	* Converts hyphens and camel casing to underscores.
-	* @returns Returns a converted string.
-	* @example
-	*   'a-farewell-to-arms'.underscore() -> 'a_farewell_to_arms'
-	*   'capsLock'.underscore()           -> 'caps_lock'
-	* @note Not to be confused with the populate underscore.js library.
-	**/
-	underscore(): string;
-
-	/**
-	* Restores escaped HTML characters.
-	* @returns Returns unescaped HTML string.
-	* @example
-	*   '&lt;p&gt;some text&lt;/p&gt;'.unescapeHTML() -> '<p>some text</p>'
-	*   'one &amp; two'.unescapeHTML()                -> 'one & two'
-	**/
-	unescapeHTML(): string;
-
-	/**
-	* Restores escaped characters in a URL escaped string.
-	* @param partial If true only escape non-valid URL characters, default = false.
-	* @returns String
-	* @extra If [partial] is true, it will only unescape non-valid URL characters. [partial] is included here for completeness, but should very rarely be needed.
-	* @example
-	*   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL()     -> 'http://foo.com/the bar'
-	*   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL(true) -> 'http%3A%2F%2Ffoo.com%2Fthe bar'
-	**/
-	unescapeURL(partial?: boolean): string;
-
-	/**
-	* Runs callback [fn] against each word in the string.
-	* @param fn Callback to run against each word in the string.
-	* @returns Returns an string[] with each element containing a word.
-	* @extra A "word" here is defined as any sequence of non-whitespace characters.
-	* @example
-	*   'broken wear'.words() -> ['broken','wear']
-	*   'broken wear'.words(function(w) {
-	*     // Called twice: "broken", "wear"
-	*   });
-	**/
-	words(fn?: (word: string) => void): string[];
-
-	/**
-	* Converts half-width characters (hankaku) to full-width (zenkaku).
-	* @param modes Types of characters to convert, default = 'all'.
-	* @returns String
-	* @extra [mode] accepts any combination of
-	*        "a" (alphabet),
-	*        "n" (numbers),
-	*        "k" (katakana),
-	*        "s" (spaces),
-	*        "p" (punctuation),
-	*        or "all".
-	* @example
-	*   '??? YAMADA??!'.zenkaku()                         -> '??? YAMADA??!'
-	*   '??? YAMADA??!'.zenkaku('a')                      -> '??? YAMADA??!'
-	*   '??? YAMADA??!'.zenkaku('alphabet')               -> '??? YAMADA??!'
-	*   '?????! 25???!'.zenkaku('katakana', 'numbers') -> '?????! 25???!'
-	*   '?????! 25???!'.zenkaku('k', 'n')              -> '?????! 25???!'
-	*   '?????! 25???!'.zenkaku('kn')                  -> '?????! 25???!'
-	*   '?????! 25???!'.zenkaku('sp')                  -> '?????! 25???!'
-	**/
-	zenkaku(...modes: string[]): string;
-}
-
-// Todo: fix when TypeScript supports adding static functions to native types.
-interface NumberConstructor {
-
-	/**
-	* Returns a random integer between [n1] and [n2].
-	* @param n1 Lower bound, default = 0.
-	* @param n2 Uppder bound, default = 1.
-	* @returns Random number between [n1] and [n2].
-	* @extra If only 1 number is passed, the other will be 0. If none are passed, the number will be either 0 or 1.
-	* @example
-	*   Number.random(50, 100) -> ex. 85
-	*   Number.random(50)      -> ex. 27
-	*   Number.random()        -> ex. 0
-	**/
-	random(n1?: number, n2?: number): number;
-}
-
-interface Number {
-
-	/**
-	* Returns an abbreviated form of the number.
-	* @param precision Rounding precision, default = 0.
-	* @returns Abbreviated string representation of the number.
-	* @extra [precision] will round to the given precision.
-	* @example
-	*   (1000).abbr()    -> "1k"
-	*   (1000000).abbr() -> "1m"
-	*   (1280).abbr(1)   -> "1.3k"
-	**/
-	abbr(precision?: number): string;
-
-	/**
-	* Returns an abbreviated form of the number, considered to be "Bytes".
-	* @param precision Rounding precision, default = 0.
-	* @param limit Upper limit for the units, default = 4 which is terabytes.
-	* @returns Abbreviated string representation of the number in bytes.
-	* @extra [precision] will round to the given precision.
-	*        [limit] is the upper limit for the units.
-	*        The default is %4%, which is "terabytes" (TB).
-	*        If [limit] is %false%, the upper limit will be "exa".
-	* @example
-	*   (1000).bytes()                 -> "1kB"
-	*   (1000).bytes(2)                -> "0.98kB"
-	*   ((10).pow(20)).bytes()         -> "90,949,470TB"
-	*   ((10).pow(20)).bytes(0, false) -> "87EB"
-	**/
-	bytes(precision?: number, limit?: number): string;
-
-	/*
-	* @see bytes
-	* @limit If false upper limit for units is 'exa'.
-	**/
-	bytes(precision?: number, limit?: boolean): string;
-
-	/**
-	* Shortcut for %Math.ceil% that also allows a <precision>.
-	* @param precision Rounding precision, default = 0.
-	* @returns Ceiling rounded number.
-	* @example
-	*   (3.241).ceil()  -> 4
-	*   (-3.241).ceil() -> -3
-	*   (3.241).ceil(2) -> 3.25
-	*   (3748).ceil(-2) -> 3800
-	**/
-	ceil(precision?: number): number;
-
-	/**
-	* Returns a string at the code point of the number.
-	* @returns String from character code.
-	* @example
-	*   (65).chr() -> "A"
-	*   (75).chr() -> "K"
-	**/
-	chr(): string;
-
-	/**
-	* Returns an array containing numbers from the number down to <num>.
-	* @param num Number to count down to.
-	* @param fn Callback function to call for each number.
-	* @param step Number to subtract each iteration, default = 1.
-	* @returns number[] containing numbers from number down to <num>.
-	* @extra Optionally calls [fn] callback for each number in that array.
-	*        [step] allows multiples greater than 1.
-	* @example
-	*   (8).downto(3) -> [8, 7, 6, 5, 4, 3]
-	*   (8).downto(3, function(n) {
-	*     // This function is called 6 times receiving n as the value.
-	*   });
-	*   (8).downto(2, null, 2) -> [8, 6, 4, 2]
-	**/
-	downto(num: number, fn?: (n: number) => void, step?: number): number[];
-
-	/**
-	* Takes the number as milliseconds and returns a unit-adjusted localized string.
-	* @param locale Locale to convert the ms to, default = currentLocale.
-	* @returns String representation of the duration in [locale].
-	* @extra This method is the same as %Date#relative% without
-	*        the localized equivalent of "from now" or "ago".
-	*        [locale] can be passed as the first (and only) parameter.
-	*        Note that this method is only available when the dates
-	*        package is included.
-	* @example
-	*   (500).duration() -> '500 milliseconds'
-	*   (1200).duration() -> '1 second'
-	*   (75).minutes().duration() -> '1 hour'
-	*   (75).minutes().duration('es') -> '1 hora'
-	**/
-	duration(locale?: string): string;
-
-	/**
-	* Shortcut for %Math.floor% that also allows a <precision>.
-	* @param precision Rounding precision, default = 0.
-	* @returns Floor rounded number.
-	* @example
-	*   (3.241).floor()  -> 3
-	*   (-3.841).floor() -> -4
-	*   (3.241).floor(2) -> 3.24
-	*   (3748).floor(-2) -> 3700
-	**/
-	floor(precision?: number): number;
-
-	/**
-	* Formats the number to a readable string.
-	* @method format([place] = 0, [thousands] = ',', [decimal] = '.')
-	* @param place default = 0.
-	* @param thousands Thousands character, default = ','.
-	* @param decimal Decimal character, default = '.'.
-	* @returns String
-	* @extra If [place] is %undefined%, will automatically determine the place.
-	*        [thousands] is the character used for the thousands separator.
-	*        [decimal] is the character used for the decimal point.
-	* @example
-	*   (56782).format()           -> '56,782'
-	*   (56782).format(2)          -> '56,782.00'
-	*   (4388.43).format(2, ' ')      -> '4 388.43'
-	*   (4388.43).format(2, '.', ',') -> '4.388,43'
-	**/
-	format(place?: number, thousands?: string, decimal?: string): string;
-
-	/**
-	* Converts the number to hexidecimal.
-	* @method hex([pad] = 1)
-	* @param pad Number of characters to pad.
-	* @returns Hexidecimal number.
-	* @extra [pad] will pad the resulting string to that many places.
-	* @example
-	*   (255).hex()   -> 'ff';
-	*   (255).hex(4)  -> '00ff';
-	*   (23654).hex() -> '5c66';
-	**/
-	hex(pad?: number): string;
-
-	/**
-	* Returns true if the number is even.
-	* @returns True if the number is even, otherwise false.
-	* @example
-	*   (6).isEven()  -> true
-	*   (17).isEven() -> false
-	**/
-	isEven(): boolean;
-
-	/**
-	* Returns true if the number has no trailing decimal.
-	* @returns True if the number is an integer, otherwise false.
-	* @example
-	*   (420).isInteger() -> true
-	*   (4.5).isInteger() -> false
-	**/
-	isInteger(): boolean;
-
-	/**
-	* Returns true if the number is a multiple of <num>.
-	* @param num Number to check for multiple of.
-	* @returns True if the number is a multiple of <num>.
-	* @example
-	*   (6).isMultipleOf(2)  -> true
-	*   (17).isMultipleOf(2) -> false
-	*   (32).isMultipleOf(4) -> true
-	*   (34).isMultipleOf(4) -> false
-	**/
-	isMultipleOf(num: number): boolean;
-
-	/**
-	* Returns true if the number is odd.
-	* @returns True if the number is odd, otherwise false.
-	* @example
-	*   (3).isOdd()  -> true
-	*   (18).isOdd() -> false
-	**/
-	isOdd(): boolean;
-
-	/**
-	* Returns the logarithm of the number with base <base>,
-	* or natural logarithm of the number if <base> is undefined.
-	* @param base default = Math.E.
-	* @returns Logarithm of the number with base <base>.
-	* @example
-	*   (64).log(2) -> 6
-	*   (9).log(3)  -> 2
-	*   (5).log()   -> 1.6094379124341003
-	**/
-	log(base?: number): number;
-
-	/**
-	* Determines the absolute value of the number.
-	* @returns Absolute value of the number.
-	* @example
-	*   (-3).abs() -> 3
-	**/
-	abs(): number;
-
-	/**
-	* sine
-	**/
-	sin(): number;
-
-	/**
-	* arcsine
-	**/
-	asin(): number;
-
-	/**
-	* cosine
-	**/
-	cos(): number;
-
-	/**
-	* arccosine
-	**/
-	acos(): number;
-
-	/**
-	* tangent
-	**/
-	tan(): number;
-
-	/**
-	* arctangent
-	**/
-	atan(): number;
-
-	/**
-	* @example
-	*   (1024).sqrt() -> 32
-	**/
-	sqrt(): number;
-
-	/**
-	* E^X
-	**/
-	exp(): number;
-
-	/**
-	* n^m
-	* @example
-	*   (3).pow(3) -> 27
-	**/
-	pow(num: number): number;
-
-	/***
-	* Returns the number as a string in metric notation.
-	* @method metric([precision] = 0, [limit] = 1)
-	* @param precision Rounding precision, default = 0.
-	* @param limit Upper limit for the metric units, default = 1 which is kilo.
-	* @returns Metric string notation for the number.
-	* @extra [precision] will round to the given precision.
-	*        Both very large numbers and very small numbers are supported.
-	*        [limit] is the upper limit for the units.
-	*        The default is %1%, which is "kilo".
-	*        If [limit] is %false%, the upper limit will be "exa".
-	*        The lower limit is "nano", and cannot be changed.
-	* @example
-	*   (1000).metric()            -> "1k"
-	*   (1000000).metric()         -> "1,000k"
-	*   (1000000).metric(0, false) -> "1M"
-	*   (1249).metric(2) + 'g'     -> "1.25kg"
-	*   (0.025).metric() + 'm'     -> "25mm"
-	**/
-	metric(precision?: number, limit?: number): string;
-
-	/**
-	* @see metric
-	* @limit If false the upper limit for the metric units will be 'exa'.
-	**/
-	metric(precision?: number, limit?: boolean): string;
-
-	/**
-	* Returns an ordinalized (English) string, i.e. "1st", "2nd", etc.
-	* @returns Ordinalized string number equivalent.
-	* @example
-	*   (1).ordinalize() -> '1st';
-	*   (2).ordinalize() -> '2nd';
-	*   (8).ordinalize() -> '8th';
-	**/
-	ordinalize(): string;
-
-	/**
-	* Pads a number with "0" to <place>.
-	* @method pad(<place> = 0, [sign] = false, [base] = 10)
-	* @param place Pad up to this many characters, default = 0.
-	* @param sign True to force the sign (+/-), default = false.
-	* @param base The base of the new number, default = 10.
-	* @returns Padded number.
-	* @extra [sign] allows you to force the sign as well (+05, etc). [base] can change the base for numeral conversion.
-	* @example
-	*   (5).pad(2)        -> '05'
-	*   (-5).pad(4)       -> '-0005'
-	*   (82).pad(3, true) -> '+082'
-	**/
-	pad(place?: number, sign?: boolean, base?: number): string;
-
-	/**
-	* Shortcut for %Math.round% that also allows a [precision].
-	* @param precision Rounding precision, default = 0.
-	* @returns Rounded number to [precision].
-	* @example
-	*   (3.241).round()  -> 3
-	*   (-3.841).round() -> -4
-	*   (3.241).round(2) -> 3.24
-	*   (3748).round(-2) -> 3800
-	**/
-	round(precision?: number): number;
-
-	/***
-	* Calls <fn> a number of times equivalent to the number.
-	* @param fn Callback function to call n times.
-	* @returns The original number.
-	* @example
-	*   (8).times(function(i) {
-	*     // This function is called 8 times.
-	*   });
-	***/
-	times(fn: (i: number) => void): number;
-
-	/***
-	* Returns a number. This is mostly for compatibility reasons.
-	* @returns The original number.
-	* @example
-	*   (420).toNumber() -> 420
-	***/
-	toNumber(): number;
-
-	/**
-	* Takes the number as a corresponding unit of time and converts to [unit].
-	* @method [unit]()
-	* @returns Number
-	* @extra Method names can be both singular and plural.
-	*        Note that as "a month" is ambiguous as a unit of time,
-	*        %months% will be equivalent to 30.4375 days, the average
-	*        number in a month. Be careful using %months% if you need
-	*        exact precision.
-	* @set
-	*   millisecond
-	*   milliseconds
-	*   second
-	*   seconds
-	*   minute
-	*   minutes
-	*   hour
-	*   hours
-	*   day
-	*   days
-	*   week
-	*   weeks
-	*   month
-	*   months
-	*   year
-	*   years
-	* @example
-	*   (5).milliseconds() -> 5
-	*   (10).hours()       -> 36000000
-	*   (1).day()          -> 86400000
-	**/
-	millisecond(): number;
-
-	/**
-	* @see millisecond
-	**/
-	milliseconds(): number;
-
-	/**
-	* @see millisecond
-	**/
-	second(): number;
-
-	/**
-	* @see millisecond
-	**/
-	seconds(): number;
-
-	/**
-	* @see millisecond
-	**/
-	minute(): number;
-
-	/**
-	* @see millisecond
-	**/
-	minutes(): number;
-
-	/**
-	* @see millisecond
-	**/
-	hour(): number;
-
-	/**
-	* @see millisecond
-	**/
-	hours(): number;
-
-	/**
-	* @see millisecond
-	**/
-	day(): number;
-
-	/**
-	* @see millisecond
-	**/
-	days(): number;
-
-	/**
-	* @see millisecond
-	**/
-	week(): number;
-
-	/**
-	* @see millisecond
-	**/
-	weeks(): number;
-
-	/**
-	* @see millisecond
-	**/
-	month(): number;
-
-	/**
-	* @see millisecond
-	**/
-	months(): number;
-
-	/**
-	* @see millisecond
-	**/
-	year(): number;
-
-	/**
-	* @see millisecond
-	**/
-	years(): number;
-
-	/**
-	* Returns a date <n> units after <d>, where <n> is the number.
-	* @method [unit]After([d], [locale] = currentLocale)
-	* @param d Date to start from.
-	* @param locale Locale for return Date, default = currentLocale.
-	* @returns Date <n> units after <d>.
-	* @extra [d] will accept a date object, timestamp, or text format.
-	*        Note that "months" is ambiguous as a unit of time. If the
-	*        target date falls on a day that does not exist
-	*        (ie. August 31 -> February 31), the date will be shifted
-	*        to the last day of the month. Be careful using %monthsAfter%
-	*        if you need exact precision. See @date_format for more.
-	* @set
-	*   millisecondAfter
-	*   millisecondsAfter
-	*   secondAfter
-	*   secondsAfter
-	*   minuteAfter
-	*   minutesAfter
-	*   hourAfter
-	*   hoursAfter
-	*   dayAfter
-	*   daysAfter
-	*   weekAfter
-	*   weeksAfter
-	*   monthAfter
-	*   monthsAfter
-	*   yearAfter
-	*   yearsAfter
-	* @example
-	*   (5).daysAfter('tuesday')          -> 5 days after tuesday of this week
-	*   (1).yearAfter('January 23, 1997') -> January 23, 1998
-	**/
-	millisecondAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	millisecondAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	millisecondsAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	millisecondsAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	secondAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	secondAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	secondsAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	secondsAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	minuteAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	minuteAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	minutesAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	minutesAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	hourAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	hourAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	hoursAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	hoursAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	dayAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	dayAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	daysAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	daysAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	weekAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	weekAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	weeksAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	weeksAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	monthAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	monthAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	monthsAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	yearAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	yearAfter(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	yearsAfter(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondAfter
-	**/
-	yearsAfter(d: Date, locale?: string): Date;
-
-	/**
-	* Returns a date that is <n> units ago.
-	* @method [unit]Ago()
-	* @returns Date
-	* @extra Note that "months" is ambiguous as a unit of time.
-	*        If the target date falls on a day that does not exist
-	*        (ie. August 31 -> February 31), the date will be shifted
-	*        to the last day of the month. Be careful using %monthsAgo%
-	*        if you need exact precision.
-	* @set
-	*   millisecondAgo
-	*   millisecondsAgo
-	*   secondAgo
-	*   secondsAgo
-	*   minuteAgo
-	*   minutesAgo
-	*   hourAgo
-	*   hoursAgo
-	*   dayAgo
-	*   daysAgo
-	*   weekAgo
-	*   weeksAgo
-	*   monthAgo
-	*   monthsAgo
-	*   yearAgo
-	*   yearsAgo
-	* @example
-	*   (5).weeksAgo() -> 5 weeks ago
-	*   (1).yearAgo()  -> January 23, 1996
-	**/
-	millisecondAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	millisecondsAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	secondAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	secondsAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	minuteAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	minutesAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	hourAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	hoursAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	dayAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	daysAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	weekAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	weeksAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	monthAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	monthsAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	yearAgo(): Date;
-
-	/**
-	* @see millisecondAgo
-	**/
-	yearsAgo(): Date;
-
-	/**
-	* Returns a date that is <n> units before <d>, where <n> is the number.
-	* @method [unit]Before([d], [locale] = currentLocale)
-	* @param d Date to start from.
-	* @param locale Locale for return Date, default = currentLocale.
-	* @returns Date <n> units before <d>.
-	* @extra [d] will accept a date object, timestamp, or text format.
-	*        Note that "months" is ambiguous as a unit of time. If the
-	*        target date falls on a day that does not exist
-	*        (ie. August 31 -> February 31), the date will be shifted to
-	*        the last day of the month. Be careful using %monthsBefore%
-	*        if you need exact precision. See @date_format for more.
-	* @set
-	*   millisecondBefore
-	*   millisecondsBefore
-	*   secondBefore
-	*   secondsBefore
-	*   minuteBefore
-	*   minutesBefore
-	*   hourBefore
-	*   hoursBefore
-	*   dayBefore
-	*   daysBefore
-	*   weekBefore
-	*   weeksBefore
-	*   monthBefore
-	*   monthsBefore
-	*   yearBefore
-	*   yearsBefore
-	* @example
-	*   (5).daysBefore('tuesday')          -> 5 days before tuesday of this week
-	*   (1).yearBefore('January 23, 1997') -> January 23, 1996
-	**/
-	millisecondBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	millisecondBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	millisecondsBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	millisecondsBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	secondBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	secondBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	secondsBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	secondsBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	minuteBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	minuteBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	minutesBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	minutesBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	hourBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	hourBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	hoursBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	hoursBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	dayBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	dayBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	daysBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	daysBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	weekBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	weekBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	weeksBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	weeksBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	monthBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	monthBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	monthsBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	monthsBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	yearBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	yearBefore(d: Date, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	yearsBefore(d: string, locale?: string): Date;
-
-	/**
-	* @see millisecondBefore
-	**/
-	yearsBefore(d: Date, locale?: string): Date;
-
-	/**
-	* Returns a date <n> units from now.
-	* @method [unit]FromNow()
-	* @returns Date
-	* @extra Note that "months" is ambiguous as a unit of time.
-	*        If the target date falls on a day that does not exist
-	*        (ie. August 31 -> February 31), the date will be shifted
-	*        to the last day of the month. Be careful using %monthsFromNow%
-	*        if you need exact precision.
-	* @set
-	*   millisecondFromNow
-	*   millisecondsFromNow
-	*   secondFromNow
-	*   secondsFromNow
-	*   minuteFromNow
-	*   minutesFromNow
-	*   hourFromNow
-	*   hoursFromNow
-	*   dayFromNow
-	*   daysFromNow
-	*   weekFromNow
-	*   weeksFromNow
-	*   monthFromNow
-	*   monthsFromNow
-	*   yearFromNow
-	*   yearsFromNow
-	* @example
-	*   (5).weeksFromNow() -> 5 weeks ago
-	*   (1).yearFromNow()  -> January 23, 1998
-	**/
-	millisecondFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	millisecondsFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	secondFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	secondsFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	minuteFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	minutesFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	hourFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	hoursFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	dayFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	daysFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	weekFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	weeksFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	monthFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	monthsFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	yearFromNow(): Date;
-
-	/**
-	* @see millisecondFromNow
-	**/
-	yearsFromNow(): Date;
-
-	/**
-	* Returns an array containing numbers from the number up to <num>.
-	* @param num Number to count down to.
-	* @param fn Callback function to call for each number.
-	* @param step Number to add each iteration, default = 1.
-	* @returns number[] containing numbers from number up to <num>.
-	* @extra Optionally calls [fn] callback for each number in that array.
-	*       [step] allows multiples greater than 1.
-	* @example
-	*   (2).upto(6) -> [2, 3, 4, 5, 6]
-	*   (2).upto(6, function(n) {
-	*     // This function is called 5 times receiving n as the value.
-	*   });
-	*   (2).upto(8, null, 2) -> [2, 4, 6, 8]
-	**/
-	upto(num: number, fn?: Function, step?: number): number[];
-}
-
-//Static members on native types.
-interface ArrayConstructor {
-
-	/**
-	* Alternate array constructor.
-	* @param args Elements to create the array from.
-	* @returns Array containing the elements in <args>.
-	* @extra This method will create a single array by calling %concat%
-	*        on all arguments passed. In addition to ensuring that an unknown
-	*        variable is in a single, flat array (the standard constructor will
-	*        create nested arrays, this one will not), it is also a useful
-	*        shorthand to convert a function's arguments object into a standard
-	*        array.
-	* @example
-	*   Array.create('one', true, 3)   -> ['one', true, 3]
-	*   Array.create(['one', true, 3]) -> ['one', true, 3]
-	*   Array.create(function(n) {
-	*     return arguments;
-	*   }('howdy', 'doody'));
-	**/
-	create<T>(...args: T[]): T[];
-
-	/**
-	* Returns true if <obj> is an Array.
-	* @param obj Object to check if it is an Array.
-	* @returns True if <obj> is of type Array.
-	* @extra This method is provided for browsers that don't support it internally.
-	* @example
-	*   Array.isArray(3)        -> false
-	*   Array.isArray(true)     -> false
-	*   Array.isArray('wasabi') -> false
-	*   Array.isArray([1,2,3])  -> true
-	**/
-	isArray(obj: any): boolean;
-}
-
-interface Array<T> {
-
-	/**
-	* Adds <el> to the array.
-	* @param el Elements to add to the array.
-	* @param index Specifies the index where to insert/add <el> into the array, default = Array.length
-	* @returns Array containing the added <el> elements at position <index>.
-	* @extra If [index] is specified, it will add at [index], otherwise
-	*        adds to the end of the array. %add% behaves like %concat%
-	*        in that if <el> is an array it will be joined, not inserted.
-	*        This method will change the array! Use %include% for a
-	*        non-destructive alias. Also, %insert% is provided as an
-	*        alias that reads better when using an index.
-	* @example
-	*   [1,2,3,4].add(5)       -> [1,2,3,4,5]
-	*   [1,2,3,4].add([5,6,7]) -> [1,2,3,4,5,6,7]
-	*   [1,2,3,4].insert(8, 1) -> [1,8,2,3,4]
-	**/
-	add(el: T, index?: number): T[];
-
-	/**
-	* @see add
-	**/
-	add(el: T[], index?: number): T[];
-
-	/**
-	* @see add
-	**/
-	insert(el: T, index?: number): T[];
-
-	/**
-	* @see add
-	**/
-	insert(el: T[], index?: number): T[];
-
-	/***
-	* Gets the element(s) at a given index.
-	* @param index Element's index to retrieve.
-	* @param loop Continue counting if the index overshoots the Array.length
-	* @returns The element at <index>.
-	* @extra When [loop] is true, overshooting the end of the array (or the beginning)
-	*        will begin counting from the other end. As an alternate syntax, passing
-	*        multiple indexes will get the elements at those indexes.
-	* @example
-	*   [1,2,3].at(0)        -> 1
-	*   [1,2,3].at(2)        -> 3
-	*   [1,2,3].at(4)        -> 2
-	*   [1,2,3].at(4, false) -> null
-	*   [1,2,3].at(-1)       -> 3
-	*   [1,2,3].at(0,1)      -> [1,2]
-	**/
-	at(index: number, loop?: boolean): T;
-
-	/**
-	* @see at
-	* @param start Start index.
-	* @param end End index.
-	* @return Elements between <start> and <end>
-	**/
-	at(start: number, stop: number): T[];
-
-	/**
-	* Averages all values in the array.
-	* @param map Maps each element to a number.
-	* @returns The average of the entire array.
-	* @extra [map] may be a function mapping the value to be averaged or
-	*        a string acting as a shortcut.
-	* @example
-	*   [1,2,3].average()                           -> 2
-	*   [{age:35},{age:11},{age:11}].average(function(n) {
-	*     return n.age;
-	*   });                                         -> 19
-	*   [{age:35},{age:11},{age:11}].average('age') -> 19
-	**/
-	average(map?: (e: T) => number): number;
-
-	/**
-	* Clones the array.
-	* @returns Cloned array.
-	* @example
-	*   [1,2,3].clone() -> [1,2,3]
-	**/
-	clone(): T[];
-
-	/**
-	* Removes all instances of %undefined%, %null%, and %NaN% from the array.
-	* @param all Remove false elements, default = false.
-	* @returns The same array with the special values removed.
-	* @extra If [all] is %true%, all "falsy" elements will be removed. This includes empty strings, 0, and false.
-	* @example
-	*   [1,null,2,undefined,3].compact() -> [1,2,3]
-	*   [1,'',2,false,3].compact()       -> [1,'',2,false,3]
-	*   [1,'',2,false,3].compact(true)   -> [1,2,3]
-	**/
-	compact(all?: boolean): T[];
-
-	/**
-	* Counts all elements in the array that match <f>.
-	* @param f object to match against in the array.
-	* @returns Number of elements in the array that match <f>.
-	* @extra <f> will match a string, number, array, object, or alternately test against a function or regex. This method implements @array_matching.
-	* @example
-	*   [1,2,3,1].count(1)       -> 2
-	*   ['a','b','c'].count(/b/) -> 1
-	*   [{a:1},{b:2}].count(function(n) {
-	*     return n['a'] > 1;
-	*   });                      -> 0
-	**/
-	count(f: T): number;
-
-	/**
-	* Runs <fn> against each element in the array. Enhanced version of %Array#forEach%.
-	* @param fn Callback function for applied to each element in the array.
-	* @param index Starting index, default = 0.
-	* @param loop Continue from the beginning if the end of the array is reached, default = false.
-	* @returns Original array.
-	* @extra Parameters passed to <fn> are identical to %forEach%,
-	*        ie. the first parameter is the current element, second
-	*        parameter is the current index, and third parameter is
-	*        the array itself. If <fn> returns %false% at any time
-	*        it will break out of the loop. Once %each% finishes,
-	*        it will return the array. If [index] is passed, <fn> will
-	*        begin at that index and work its way to the end. If [loop]
-	*        is true, it will then start over from the beginning of the
-	*        array and continue until it reaches [index] - 1.
-	* @example
-	*   [1,2,3,4].each(function(n) {
-	*     // Called 4 times: 1, 2, 3, 4
-	*   });
-	*   [1,2,3,4].each(function(n) {
-	*     // Called 4 times: 3, 4, 1, 2
-	*   }, 2, true);
-	**/
-	each(
-		fn: (element: T, index?: number, array?: T[]) => any,
-		index?: number,
-		loop?: boolean): T[];
-
-	/**
-	* Returns true if all elements in the array match <f>.
-	* @param f Match all elements to this.
-	* @param scope [this] object.
-	* @returns Boolean
-	* @extra [scope] is the %this% object. %all% is provided an alias.
-	*        In addition to providing this method for browsers that don't
-	*        support it natively, this method also implements @array_matching.
-	* @example
-	*   ['a','a','a'].every(function(n) {
-	*     return n == 'a';
-	*   });
-	*   ['a','a','a'].every('a')   -> true
-	*   [{a:2},{a:2}].every({a:2}) -> true
-	**/
-	every(f: T, scope?: any): boolean;
-
-	/**
-	* @see every
-	* @note Already defined in lib.d.ts.
-	**/
-	//every(f: (element: T, index: number, array: T[]) => boolean, scope?: any): boolean;
-
-	/**
-	* @see every
-	**/
-	all(f: T, scope?: any): boolean;
-
-	/**
-	* @see every
-	**/
-	all(f: (element: T, index: number, array: T[]) => boolean, scope?: any): boolean;
-
-	/**
-	* Removes any element in the array that matches [f1], [f2], etc.
-	* @param f Elements to find in the array and remove.
-	* @returns A copy of the original array with all instances of <f> removed.
-	* @extra This is a non-destructive alias for %remove%. It will not change the original array. This method implements @array_matching.
-	* @example
-	*   [1,2,3].exclude(3)         -> [1,2]
-	*   ['a','b','c'].exclude(/b/) -> ['a','c']
-	*   [{a:1},{b:2}].exclude(function(n) {
-	*     return n['a'] == 1;
-	*   });                       -> [{b:2}]
-	**/
-	exclude(...f: T[]): T[];
-
-	/**
-	* @see exclude
-	**/
-	exclude(f: (element: T, index: number, array: T[]) => boolean): T[];
-
-	/**
-	* Returns any elements in the array that match <f>.
-	* @param f Find these elements in the array.
-	* @param scope %this% object while filtering.
-	* @returns Array containing th items <f> found in the array.
-	* @extra [scope] is the %this% object. In addition to providing this
-	*        method for browsers that don't support it natively, this method
-	*        also implements @array_matching.
-	* @example
-	*   [1,2,3].filter(function(n) {
-	*     return n > 1;
-	*   });
-	*   [1,2,2,4].filter(2) -> 2
-	**/
-	filter(f: T, scope?: any): T[];
-
-	/**
-	* @see filter
-	* @note Already defined in lib.d.ts.
-	**/
-	//filter(f: (element: T, index: number, array: T[]) => boolean, scope?: any): T[];
-
-	/**
-	* Returns the first element that matches <f>.
-	* @param f Elements to match against.
-	* @param index Index to start searching from, default = 0.
-	* @param loop Loop around the end of the array, default = false.
-	* @returns First element matching <f>.
-	* @extra <f> will match a string, number, array, object, or alternately
-	*        test against a function or regex. Starts at [index], and will
-	*        continue once from index = 0 if [loop] is true. This method
-	*        implements @array_matching.
-	* @example
-	*   [{a:1,b:2},{a:1,b:3},{a:1,b:4}].find(function(n) {
-	*     return n['a'] == 1;
-	*   });                                     -> {a:1,b:3}
-	*   ['cuba','japan','canada'].find(/^c/, 2) -> 'canada'
-	**/
-	find(f: T, index?: number, loop?: boolean): T;
-
-	/**
-	* @see find
-	**/
-	find(f: (element: T, index: number, array: T[]) => boolean, index?: number, loop?: boolean): T;
-
-	/**
-	* Returns all elements that match <f>.
-	* @param f Element to match against.
-	* @param index Index to start searching from, default = 0.
-	* @param loop Loop around the end of the array, default = false.
-	* @returns Elements matching <f>.
-	* @extra <f> will match a string, number, array, object, or alternately
-	*        test against a function or regex. Starts at [index], and will
-	*        continue once from index = 0 if [loop] is true. This method
-	*        implements @array_matching.
-	* @example
-	*   [{a:1,b:2},{a:1,b:3},{a:2,b:4}].findAll(function(n) {
-	*     return n['a'] == 1;
-	*   });                                        -> [{a:1,b:3},{a:1,b:4}]
-	*   ['cuba','japan','canada'].findAll(/^c/)    -> 'cuba','canada'
-	*   ['cuba','japan','canada'].findAll(/^c/, 2) -> 'canada'
-	**/
-	findAll(f: T, index?: number, loop?: boolean): T[];
-
-	/**
-	* @see findAll
-	**/
-	findAll(f: (element: T, index: number, array: T[]) => boolean, index?: number, loop?: boolean): T[];
-
-	/**
-	* Returns the index of the first element that matches <f>
-	*        or -1 if not found.
-	* @method findIndex(<f>, [startIndex] = 0, [loop] = false)
-	* @param f Element to match against.
-	* @param startIndex Index to start searching from, default = 0.
-	* @param loop Loop around the end of th array, default = false.
-	* @returns Index at which <f> is found.
-	* @extra This method has a few notable differences to native %indexOf%.
-	*        Although <f> will similarly match a primitive such as a string
-	*        or number, it will also match deep objects and arrays that are
-	*        not equal by reference (%===%). Additionally, if a function is
-	*        passed it will be run as a matching function (similar to the
-	*        behavior of %Array#filter%) rather than attempting to find that
-	*        function itself by reference in the array. Starts at [index],
-	*        and will continue once from index = 0 if [loop] is true.
-	*        This method implements @array_matching.
-	* @example
-	*   [1,2,3,4].findIndex(3);  -> 2
-	*   [1,2,3,4].findIndex(function(n) {
-	*     return n % 2 == 0;
-	*   }); -> 1
-	*   ['one','two','three'].findIndex(/th/); -> 2
-	**/
-	findIndex(f: T, startIndex?: number, loop?: boolean): number;
-
-	/**
-	* @see findIndex
-	**/
-	findIndex(f: (element: T, index: number, array: T[]) => boolean, startIndex?: number, loop?: boolean): number;
-
-	/**
-	* Returns the first element(s) in the array.
-	* @param num Retrieve this many elements in the array, default = 1.
-	* @returns <num> first elements in the array.
-	* @extra When <num> is passed, returns the first <num> elements in the array.
-	* @note If <num> is omitted then the return type is the element itself, not an array of the element,
-	*       For example 1 instead of [1], however if <num> is present the result is always wrapped in an
-	*       array like first(1) -> [1], not 1.
-	* @example
-	*   [1,2,3].first()        -> 1
-	*   [1,2,3].first(2)       -> [1,2]
-	**/
-	first(): T;
-
-	/**
-	* @see first
-	**/
-	first(num: number): T[];
-
-	/**
-	* Returns a flattened, one-dimensional copy of the array.
-	* @param limit Limit the flattening to this depth, default = Infinity.
-	* @returns Flattened array.
-	* @extra You can optionally specify a [limit], which will only flatten
-	*        that depth.
-	* @example
-	*   [[1], 2, [3]].flatten()      -> [1,2,3]
-	*   [['a'],[],'b','c'].flatten() -> ['a','b','c']
-	**/
-	flatten(limit?: number): T[];
-
-	/**
-	* Iterates over the array, calling [fn] on each loop.
-	* @param fn Callback function for each element in the array.
-	* @param scope Scope during [fn] callbacks, default = this.
-	* @returns Nothing
-	* @extra This method is only provided for those browsers that do not support
-	*        it natively. [scope] becomes the %this% object.
-	* @example
-	*   ['a','b','c'].forEach(function(a) {
-	*     // Called 3 times: 'a','b','c'
-	*   });
-	* @note Already defined in lib.d.ts.
-	**/
-	//forEach(fn: (element: T, index: number, array: T[]) => void, scope?: any): void;
-
-	/**
-	* Returns a slice of the array from <index>.
-	* @param index Index to start the slice from.
-	* @returns Subarray starting from [index] to the end of the original array.
-	* @example
-	*   [1,2,3].from(1)  -> [2,3]
-	*   [1,2,3].from(2)  -> [3]
-	**/
-	from(index: number): T[];
-
-	/**
-	* Groups the array by <map>.
-	* @param map Property on the elements in the array.
-	* @param fn Optional callback for each group, default = No callback.
-	* @returns
-	* @extra Will return an object with keys equal to the grouped values.
-	*        <map> may be a mapping function, or a string acting as a shortcut.
-	*        Optionally calls [fn] for each group.
-	* @example
-	*   ['fee','fi','fum'].groupBy('length') -> { 2: ['fi'], 3: ['fee','fum'] }
-	*   [{age:35,name:'ken'},{age:15,name:'bob'}].groupBy(function(n) {
-	*     return n.age;
-	*   });                                  -> { 35: [{age:35,name:'ken'}], 15: [{age:15,name:'bob'}] }
-	**/
-	groupBy<U>(map: string, fn?: (key: string, items: T[]) => void): { [key: string]: T };
-
-	/**
-	* @see groupBy
-	* @param map Callback function for each element, returns the key for the group the element should be in.
-	**/
-	groupBy<U>(map: (element: T) => U, fn?: (key: string, items: T[]) => void): { [key: string]: T[] };
-
-	/**
-	* Groups the array into <num> arrays.
-	* @param num The number of sub-arrays to create.
-	* @param padding Padding element if the groups do not make whole amounts.
-	* @returns Array with <num> sub-arrays.
-	* @extra [padding] specifies a value with which to pad the last array
-	*        so that they are all equal length.
-	* @example
-	*   [1,2,3,4,5,6,7].inGroups(3)         -> [ [1,2,3], [4,5,6], [7] ]
-	*   [1,2,3,4,5,6,7].inGroups(3, 'none') -> [ [1,2,3], [4,5,6], [7,'none','none'] ]
-	* @note removed because of TSC bug https://typescript.codeplex.com/workitem/1143?FocusElement=CommentTextBox
-	**/
-	//inGroups(num: number, padding?: T): T[][];
-
-	/**
-	* Groups the array into arrays of <num> elements each.
-	* @param num The number of elements to put into each sub-array.
-	* @param padding Padding element if the groups do not make whole amounts.
-	* @returns Array with sub-arrays each containing <num> elements.
-	* @extra [padding] specifies a value with which to pad the last array so that they are all equal length.
-	* @example
-	*   [1,2,3,4,5,6,7].inGroupsOf(4)         -> [ [1,2,3,4], [5,6,7] ]
-	*   [1,2,3,4,5,6,7].inGroupsOf(4, 'none') -> [ [1,2,3,4], [5,6,7,'none'] ]
-	* @note removed because of TSC bug https://typescript.codeplex.com/workitem/1143?FocusElement=CommentTextBox
-	**/
-	//inGroupsOf(num: number, padding?: T): T[][];
-
-	/**
-	* Adds <element> to the array.
-	* @param element Element to add to the array.
-	* @param index , default = Array.length.
-	* @returns Array with <element> included at [index].
-	* @extra This is a non-destructive alias for %add%. It will not change
-	*        the original array.
-	* @example
-	*   [1,2,3,4].include(5)       -> [1,2,3,4,5]
-	*   [1,2,3,4].include(8, 1)    -> [1,8,2,3,4]
-	*   [1,2,3,4].include([5,6,7]) -> [1,2,3,4,5,6,7]
-	**/
-	include(element: T, index?: number): T[];
-
-	/**
-	* @see include
-	* @param elements Elements to include into the array at [index].
-	**/
-	include(elements: T[], index?: number): T[];
-
-	/**
-	* Searches the array and returns the first index where <search> occurs, or -1 if the element is not found.
-	* @method indexOf(<search>, [fromIndex])
-	* @param search Element to search for in the array.
-	* @param fromIndex Index to start searching from, default = 0.
-	* @returns Index of <search> or -1 if <search> is not found.
-	* @extra [fromIndex] is the index from which to begin the search.
-	*        This method performs a simple strict equality comparison on <search>.
-	*        It does not support enhanced functionality such as searching
-	*        the contents against a regex, callback, or deep comparison of objects.
-	*        For such functionality, use the %findIndex% method instead.
-	* @example
-	*   [1,2,3].indexOf(3)           -> 1
-	*   [1,2,3].indexOf(7)           -> -1
-	* @note Already defined in lib.d.ts.
-	**/
-	//indexOf(search: T, fromIndex?: number): number;
-
-	/**
-	* Returns an array containing the elements all arrays have in common.
-	* @param args Elements to intersect with.
-	* @returns An array containing the intersecting elements.
-	* @extra This method will also correctly operate on arrays of objects.
-	* @example
-	*   [1,3,5].intersect([5,7,9])   -> [5]
-	*   ['a','b'].intersect('b','c') -> ['b']
-	**/
-	intersect(...args: T[]): T[];
-
-	/***
-	* Returns true if the array is empty.
-	* @returns True if the array is empty, otherwise false.
-	* @extra This is true if the array has a length of zero, or contains
-	*        only %undefined%, %null%, or %NaN%.
-	* @example
-	*   [].isEmpty()               -> true
-	*   [null,undefined].isEmpty() -> true
-	***/
-	isEmpty(): boolean;
-
-	/**
-	* Returns the last element(s) in the array.
-	* @method last([num] = 1)
-	* @returns The last element in the array, if [num] is present then it returns an array of the last [num] elements.
-	* @extra When <num> is passed, returns the last <num> elements in the array.
-	* @example
-	*   [1,2,3].last()        -> 3
-	*   [1,2,3].last(2)       -> [2,3]
-	**/
-	last(): T;
-
-	/**
-	* @see last
-	* @param num The number of elements to return.
-	**/
-	last(num: number): T[];
-
-	/**
-	* Searches the array and returns the last index where <search> occurs,
-	* or -1 if the element is not found.
-	* @param search The element to search for.
-	* @param fromIndex Start the search from this index, default = Array.length.
-	* @returns The last index of <search> or -1 if <search> is not found.
-	* @extra [fromIndex] is the index from which to begin the search.
-	*        This method performs a simple strict equality comparison on <search>.
-	* @example
-	*   [1,2,1].lastIndexOf(1)                 -> 2
-	*   [1,2,1].lastIndexOf(7)                 -> -1
-	**/
-	lastIndexOf(search: any, fromIndex?: number): number;
-
-	/**
-	* Returns the elements in the array with the least
-	*        commonly occuring value.
-	* @method least([map])
-	* @param map Property on elements in the array.
-	* @returns Array
-	* @extra [map] may be a function mapping the value to be checked or a
-	*        string acting as a shortcut.
-	* @example
-	*   [3,2,2].least()                   -> [3]
-	*   ['fe','fo','fum'].least('length') -> ['fum']
-	*   [{age:35,name:'ken'},{age:12,name:'bob'},{age:12,name:'ted'}].least(function(n) {
-	*     return n.age;
-	*   });                               -> [{age:35,name:'ken'}]
-	**/
-	least(map: string): T[];
-
-	/**
-	* @see least
-	* @param map Callback to retrieve the 'least' property to compare elements against.
-	**/
-	least<U>(map: (n: T) => U): T[];
-
-	/**
-	* Maps the array to another array containing the values that
-	*        are the result of calling <map> on each element.
-	* @param map Property on each element in the array or callback function.
-	* @param scope This pointer in <map> callback.
-	* @returns Mapped array.
-	* @extra [scope] is the %this% object. In addition to providing this method
-	*        for browsers that don't support it natively, this enhanced method
-	*        also directly accepts a string, which is a shortcut for a function
-	*        that gets that property (or invokes a function) on each element.
-	* @example
-	*   [1,2,3].map(function(n) {
-	*     return n * 3;
-	*   });                                  -> [3,6,9]
-	*   ['one','two','three'].map(function(n) {
-	*     return n.length;
-	*   });                                  -> [3,3,5]
-	*   ['one','two','three'].map('length')  -> [3,3,5]
-	**/
-	map<U>(map: string, scope?: any): U[];
-
-	/**
-	* @see map
-	* @param map Callback function to map each element in the array.
-	**/
-	map<U>(map: (n: T) => U, scope?: any): U[];
-
-	/**
-	* Returns the element in the array with the greatest value.
-	* @method max([map], [all] = false)
-	* @param map Property on each element in the array or callback function.
-	* @returns Maximum element in the array.
-	* @extra [map] may be a function mapping the value to be checked or a string
-	*        acting as a shortcut. If [all] is true, will return all max values
-	*        in an array.
-	* @example
-	*   [1,2,3].max()                          -> 3
-	*   ['fee','fo','fum'].max('length')       -> 'fee'
-	*   ['fee','fo','fum'].max('length', true) -> ['fee']
-	*   [{a:3,a:2}].max(function(n) {
-	*     return n['a'];
-	*   });                              -> {a:3}
-	**/
-	max(map?: string): T;
-
-	/**
-	* @see max
-	* @param If true return all max values in the array, default = false.
-	* @return All max values in the array.
-	**/
-	max(map: string, all: boolean): T[];
-
-	/**
-	* @see max
-	* @param map Callback function to determine the max value of each element in the array.
-	**/
-	max<U>(map: (n: T) => U): T;
-
-	/**
-	* @see max
-	**/
-	max<U>(map: (n: T) => U, all: boolean): T[];
-
-	/***
-	* Returns the element in the array with the lowest value.
-	* @param map Property on each element in the array or callback.
-	* @returns Minimum element in the array.
-	* @extra [map] may be a function mapping the value to be checked or a string acting as a shortcut. If [all] is true, will return all min values in an array.
-	* @example
-	*   [1,2,3].min()                          -> 1
-	*   ['fee','fo','fum'].min('length')       -> 'fo'
-	*   ['fee','fo','fum'].min('length', true) -> ['fo']
-	*   ['fee','fo','fum'].min(function(n) {
-	*     return n.length;
-	*   });                              -> ['fo']
-	*   [{a:3,a:2}].min(function(n) {
-	*     return n['a'];
-	*   });                              -> [{a:2}]
-	**/
-	min(map?: string): T;
-
-	/**
-	* @see min If true return all min values in the array, default = false.
-	* @param all
-	**/
-	min(map: string, all: boolean): T[];
-
-	/**
-	* @see min
-	* @param map Callback function to determine the min value of each element in the array.
-	**/
-	min<U>(map: (n: T) => U): T;
-
-	/**
-	* @see min
-	**/
-	min<U>(map: (n: T) => U, all: boolean): T[];
-
-	/**
-	* Returns the elements in the array with the most commonly occuring value.
-	* @param map Property on each element in the array or
-	* @returns Array of elements that have the most common property.
-	* @extra [map] may be a function mapping the value to be checked or a string
-	*              acting as a shortcut.
-	* @example
-	*   [3,2,2].most()                   -> [2]
-	*   ['fe','fo','fum'].most('length') -> ['fe','fo']
-	*   [{age:35,name:'ken'},{age:12,name:'bob'},{age:12,name:'ted'}].most(function(n) {
-	*     return n.age;
-	*   });                              -> [{age:12,name:'bob'},{age:12,name:'ted'}]
-	**/
-	most(map?: string): T[];
-
-	/**
-	* @see most
-	* @param map Callback function to determine the element that contains the most commonly occuring value.
-	**/
-	most<U>(map: (n: T) => U): T[];
-
-	/**
-	* Returns true if none of the elements in the array match <f>.
-	* @param f Value to see if it exists in the array.
-	* @returns True if none of the values match <f>, false if one or more match <f>.
-	* @extra <f> will match a string, number, array, object, or alternately test
-	*        against a function or regex. This method implements @array_matching.
-	* @example
-	*
-	*   [1,2,3].none(5)         -> true
-	*   ['a','b','c'].none(/b/) -> false
-	*   [{a:1},{b:2}].none(function(n) {
-	*     return n['a'] > 1;
-	*   });                     -> true
-	**/
-	none(f: T): boolean;
-
-	/**
-	* @see none
-	* @param f Callback function to determine if none of the elements in the array contain a certain value.
-	**/
-	none(f: (n: T) => boolean): boolean;
-
-	/***
-	* Returns a copy of the array with the elements randomized.
-	* @returns Copy of the array with the elements in a random order.
-	* @extra Uses Fisher-Yates algorithm.
-	* @example
-	*   [1,2,3,4].randomize()  -> [?,?,?,?]
-	***/
-	randomize(): T[];
-
-	/**
-	* Reduces the array to a single result.
-	* @param fn Reduce function callback.
-	* @param init First argument to the callback if present.
-	* @returns Reduced value of the entire array.
-	* @extra If [init] is passed as a starting value, that value will be passed
-	*        as the first argument to the callback. The second argument will be
-	*        the first element in the array. From that point, the result of the
-	*        callback will then be used as the first argument of the next
-	*        iteration. This is often refered to as "accumulation", and [init]
-	*        is often called an "accumulator". If [init] is not passed, then
-	*         <fn> will be called n - 1 times, where n is the length of the array.
-	*        In this case, on the first iteration only, the first argument will
-	*        be the first element of the array, and the second argument will be
-	*        the second. After that callbacks work as normal, using the result
-	*        of the previous callback as the first argument of the next. This
-	*        method is only provided for those browsers that do not support it
-	*        natively.
-	* @example
-	*   [1,2,3,4].reduce(function(a, b) {
-	*     return a - b;
-	*   });
-	*   [1,2,3,4].reduce(function(a, b) {
-	*     return a - b;
-	*   }, 100);
-	**/
-	reduce(fn: (a: T, b: T) => T, init: T): T;
-
-	/**
-	* Identical to %Array#reduce%, but operates on the elements in reverse order.
-	* @param fn Reduce function callback.
-	* @param init First argument to the callback if present.
-	* @returns Reduced right value of the entire array.
-	* @extra This method is only provided for those browsers that do not support
-	*        it natively.
-	* @example
-	*   [1,2,3,4].reduceRight(function(a, b) {
-	*     return a - b;
-	*   });
-	**/
-	reduceRight(fn: (a: T, b: T) => T, init: T): T;
-
-	/**
-	* Removes any element in the array that matches [f1], [f2], etc.
-	* @param args Elements that should be removed from the array.
-	* @returns The array with <args> elements removed.
-	* @extra Will match a string, number, array, object, or alternately test
-	*        against a function or regex. This method will change the array!
-	*        Use %exclude% for a non-destructive alias. This method implements
-	*        @array_matching.
-	* @example
-	*   [1,2,3].remove(3)         -> [1,2]
-	*   ['a','b','c'].remove(/b/) -> ['a','c']
-	*   [{a:1},{b:2}].remove(function(n) {
-	*     return n['a'] == 1;
-	*   });                       -> [{b:2}]
-	**/
-	remove(...args: T[]): T[];
-
-	/**
-	* @see remove
-	* @param fn Callback function to check if elements should be removed.
-	**/
-	remove(fn: (n: T) => boolean): T[];
-
-	/**
-	* Removes element at <start>. If [end] is specified, removes the range
-	*        between <start> and [end]. This method will change the array!
-	*        If you don't intend the array to be changed use %clone% first.
-	* @param start Starting index.
-	* @param end Stop index, default = Array.length.
-	* @returns Subarray with elements <start> to [end] removed.
-	* @example
-	*   ['a','b','c'].removeAt(0) -> ['b','c']
-	*   [1,2,3,4].removeAt(1, 3)  -> [1]
-	**/
-	removeAt(start: number, end?: number): T[];
-
-	/**
-	* Returns a random element from the array.
-	* @returns Single random element in the array.
-	* @extra If [num] is passed, will return [num] samples from the array.
-	* @example
-	*   [1,2,3,4,5].sample()  -> // Random element
-	*   [1,2,3,4,5].sample(3) -> // Array of 3 random elements
-	**/
-	sample(): T;
-
-	/**
-	* @see sample
-	* @param num Grab this many random elements in the array.
-	* @return <num> random elements in the array.
-	**/
-	sample(num: number): T[];
-
-	/***
-	* Returns true if any element in the array matches <f>.
-	* @method some(<f>, [scope])
-	* @param f Element to match or callback function.
-	* @param scope this object in the callback.
-	* @returns Returns true if any element in the array matchs <f>.
-	* @extra [scope] is the %this% object. %any% is provided as an alias.
-	*        In addition to providing this method for browsers that don't
-	*        support it natively, this method also implements @array_matching.
-	* @example
-	*   ['a','b','c'].some(function(n) {
-	*     return n == 'a';
-	*   });
-	*   ['a','b','c'].some(function(n) {
-	*     return n == 'd';
-	*   });
-	*   ['a','b','c'].some('a')   -> true
-	*   [{a:2},{b:5}].some({a:2}) -> true
-	**/
-	some(f: T, scope?: any): boolean;
-
-	/**
-	* @see some
-	**/
-	some(f: (n: T) => boolean, scope?: any): boolean;
-
-	/**
-	* Sorts the array by <map>.
-	* @param map Property on each element in the array or map callback function.
-	* @param desc True to sort the array in descending order, default = false.
-	* @returns Sorted array.
-	* @extra <map> may be a function, a string acting as a shortcut, or blank
-	*        (direct comparison of array values). [desc] will sort the array in
-	*        descending order. When the field being sorted on is a string, the
-	*        resulting order will be determined by an internal collation algorithm
-	*        that is optimized for major Western languages, but can be customized.
-	*        For more information see @array_sorting.
-	* @example
-	*   ['world','a','new'].sortBy('length')       -> ['a','new','world']
-	*   ['world','a','new'].sortBy('length', true) -> ['world','new','a']
-	*   [{age:72},{age:13},{age:18}].sortBy(function(n) {
-	*     return n.age;
-	*   });                                        -> [{age:13},{age:18},{age:72}]
-	**/
-	sortBy(map: string, desc?: boolean): T[];
-
-	/**
-	* @see sortBy
-	**/
-	sortBy<U>(fn: (n: T) => U, desc?: boolean): T[];
-
-	/**
-	* Subtracts from the array all elements in [a1], [a2], etc.
-	* @param args Elements to remove from the array.
-	* @returns Array with <args> removed.
-	* @extra This method will also correctly operate on arrays of objects.
-	* @example
-	*   [1,3,5].subtract([5,7,9])   -> [1,3]
-	*   [1,3,5].subtract([3],[5])   -> [1]
-	*   ['a','b'].subtract('b','c') -> ['a']
-	**/
-	subtract(...args: T[]): T[];
-
-	/**
-	* @see subtract
-	**/
-	subtract(args: T[]): T[];
-
-	/**
-	* Sums all values in the array.
-	* @param map Property on each element in the array or callback function to sum up the elements.
-	* @returns The sum of all elements in the array.
-	* @extra [map] may be a function mapping the value to be summed or a string
-	*        acting as a shortcut.
-	* @example
-	*   [1,2,2].sum()                           -> 5
-	*   [{age:35},{age:12},{age:12}].sum(function(n) {
-	*     return n.age;
-	*   });                                     -> 59
-	*   [{age:35},{age:12},{age:12}].sum('age') -> 59
-	**/
-	sum(map: string): number;
-
-    /**
-    * @see sum
-    **/
-	sum(): number;
-
-	/**
-	* @see sum
-	**/
-	sum(map: (n: T) => number): number;
-
-	/**
-	* Returns a slice of the array up to <index>.
-	* @param index Slick the array up to this index.
-	* @returns Slice of the array from 0 to <index>.
-	* @example
-	*   [1,2,3].to(1)  -> [1]
-	*   [1,2,3].to(2)  -> [1,2]
-	**/
-	to(index: number): any[];
-
-	/**
-	* Returns an array containing all elements in all arrays with duplicates removed.
-	* @method union([a1], [a2], ...)
-	* @param array
-	* @returns Union between the original array and <array>.
-	* @extra This method will also correctly operate on arrays of objects.
-	* @example
-	*   [1,3,5].union([5,7,9])     -> [1,3,5,7,9]
-	*   ['a','b'].union(['b','c']) -> ['a','b','c']
-	**/
-	union(array: T[]): T[];
-
-	/**
-	* @see union
-	* @param args Elements to create a union with.
-	* @return Union between the original array and <args>
-	**/
-	union(...args: T[]): T[];
-
-	/**
-	* Removes all duplicate elements in the array.
-	* @param map Property on each element in the array or callback function to pick a property on the element.
-	* @returns Array with only unique elements.
-	* @extra [map] may be a function mapping the value to be uniqued on or a
-	*        string acting as a shortcut. This is most commonly used when you
-	*        have a key that ensures the object's uniqueness, and don't need to
-	*        check all fields. This method will also correctly operate on arrays
-	*        of objects.
-	* @example
-	*   [1,2,2,3].unique()                 -> [1,2,3]
-	*   [{foo:'bar'},{foo:'bar'}].unique() -> [{foo:'bar'}]
-	*   [{foo:'bar'},{foo:'bar'}].unique(function(obj){
-	*     return obj.foo;
-	*   }); -> [{foo:'bar'}]
-	*   [{foo:'bar'},{foo:'bar'}].unique('foo') -> [{foo:'bar'}]
-	**/
-	unique(map?: string): T[];
-
-	/**
-	* @see unique
-	* @param fn Callback to pluck the property to check for uniqueness.
-	**/
-	unique<U>(fn: (obj: T) => U): T[];
-
-	/**
-	* Merges multiple arrays together.
-	* @param arrays Arrays to zip together.
-	* @returns Zipped arrays.
-	* @extra This method "zips up" smaller arrays into one large whose elements
-	*        are "all elements at index 0", "all elements at index 1", etc.
-	*        Useful when you have associated data that is split over separated
-	*        arrays. If the arrays passed have more elements than the original
-	*        array, they will be discarded. If they have fewer elements, the
-	*        missing elements will filled with %null%.
-	* @example
-	*   [1,2,3].zip([4,5,6])                                       -> [[1,2], [3,4], [5,6]]
-	*   ['Martin','John'].zip(['Luther','F.'], ['King','Kennedy']) -> [['Martin','Luther','King'], ['John','F.','Kennedy']]
-	* @note removed because of TSC bug https://typescript.codeplex.com/workitem/1143?FocusElement=CommentTextBox
-	**/
-	//zip(...arrays: T[]): T[][];
-}
-
-interface ObjectConstructor {
-
-	/**
-	* Creates a new object, equivalent to %new Object()% or %{}%, but with extended methods.
-	* @param obj , default = {}.
-	* @returns Extended object.
-	* @extra See extended objects for more.
-	* @example
-	*   Object.extended()
-	*   Object.extended({ happy:true, pappy:false }).keys() -> ['happy','pappy']
-	*   Object.extended({ happy:true, pappy:false }).values() -> [true, false]
-	**/
-	extended(obj?: any): any;
-
-	/**
-	* Converts the query string of a URL into an object.
-	* @method Object.fromQueryString(<str>, [deep] = true)
-	* @param str Query string to convert into an object.
-	* @param deep If false the conversion will only accept shallow params, default = true.
-	* @returns Object generated from the <str>.
-	* @extra If [deep] is %false%, conversion will only accept shallow params (ie. no object or arrays with %[]% syntax) as these are not universally supported.
-	* @example
-	*   Object.fromQueryString('foo=bar&broken=wear') -> { foo: 'bar', broken: 'wear' }
-	*   Object.fromQueryString('foo[]=1&foo[]=2')     -> { foo: [1,2] }
-	**/
-	fromQueryString<T extends {}>(str: string, deep?: boolean): T;
-
-	/**
-	* Returns true if <obj> is an object of that type.
-	* @method Object.is[Type](<obj>)
-	* @param obj Object to check if it is of type [Type].
-	* @returns True if <obj> is of type [Type].
-	* @extra %isObject% will return false on anything that is not an object
-	*        literal, including instances of inherited classes. Note also
-	*        that %isNaN% will ONLY return true if the object IS %NaN%.
-	*        It does not mean the same as browser native %isNaN%, which returns
-	*        true for anything that is "not a number".
-	* @set
-	*   isArray
-	*   isObject
-	*   isBoolean
-	*   isDate
-	*   isFunction
-	*   isNaN
-	*   isNumber
-	*   isString
-	*   isRegExp
-	* @example
-	*   Object.isArray([1,2,3])            -> true
-	*   Object.isDate(3)                   -> false
-	*   Object.isRegExp(/wasabi/)          -> true
-	*   Object.isObject({ broken:'wear' }) -> true
-	**/
-	isArray(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isObject(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isBoolean(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isDate(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isFunction(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isNaN(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isNumber(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isString(obj: any): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isRegExp(obj: any): boolean;
-
-	/**
-	* Converts the object into a query string. Accepts deep nested objects and arrays.
-	* If namespace is passed, it will be prefixed to all param names.
-	* @param obj Object to convert to a query string.
-	* @param namespace Namespace to prefix properties with in the query string.
-	* @return A query string generated from `obj` and `namespace`.
-	**/
-	toQueryString(obj: any, namespace?: string): string;
-
-	/**
-	* Creates a clone (copy) of <obj>.
-	* @method clone(<obj> = {}, [deep] = false)
-	* @param obj Object to clone.
-	* @param deep If true then deep clone, default = false.
-	* @returns Cloned object.
-	* @extra Default is a shallow clone, unless [deep] is true. %clone%
-	*        is available as an instance method on extended objects.
-	* @example
-	*   Object.clone({foo:'bar'})            -> { foo: 'bar' }
-	*   Object.clone()                       -> {}
-	*   Object.extended({foo:'bar'}).clone() -> { foo: 'bar' }
-	**/
-	clone<T extends {}>(obj?: T, deep?: boolean): T;
-
-	/**
-	* Enumerable methods in the Array package are also available to
-	*        the Object class. They will perform their normal operations for
-	*        every property in <obj>.
-	* @method [enumerable](<obj>)
-	* @returns Boolean
-	* @extra In cases where a callback is used, instead of %element, index%,
-	*        the callback will instead be passed %key, value%. Enumerable methods
-	*        are also available to extended objects as instance methods.
-	* @set
-	*   each
-	*   map
-	*   any
-	*   all
-	*   none
-	*   count
-	*   find
-	*   findAll
-	*   reduce
-	*   isEmpty
-	*   sum
-	*   average
-	*   min
-	*   max
-	*   least
-	*   most
-	* @example
-	*   Object.any({foo:'bar'}, 'bar')            -> true
-	*   Object.extended({foo:'bar'}).any('bar')   -> true
-	*   Object.isEmpty({})                        -> true
-	*   Object.map({ fred: { age: 52 } }, 'age'); -> { fred: 52 }
-	**/
-	map<T, U>(obj: T, map: string): U;
-
-	/**
-	* @see map
-	**/
-	map<T, U>(obj: T, map: (key: string, value: any) => any): U;
-
-	/**
-	* @see map
-	**/
-	each(obj: any, map: (key: string, value: any) => void): void;
-
-	/**
-	* @see map
-	**/
-	any(obj: any, map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	any(obj: any, map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	all(obj: any, map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	all(obj: any, map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	none(obj: any, map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	none(obj: any, map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	count(obj: any, map: string): number;
-
-	/**
-	* @see map
-	**/
-	count(obj: any, map: (key: string, value: any) => boolean): number;
-
-	/**
-	* @see map
-	**/
-	find(obj: any, map: string): any;
-
-	/**
-	* @see map
-	**/
-	find(obj: any, map: (key: string, value: any) => boolean): any;
-
-	/**
-	* @see map
-	**/
-	findAll(obj: any, map: string): any[];
-
-	/**
-	* @see map
-	**/
-	findAll(obj: any, map: (key: string, value: any) => boolean): any[];
-
-	/**
-	* @see map
-	**/
-	reduce(obj: any, map: string, init?: any): any;
-
-	/**
-	* @see map
-	**/
-	reduce(obj: any, map: (key: string, value: any) => any, init?: any): any;
-
-	/**
-	* @see map
-	**/
-	isEmpty(obj: any): boolean;
-
-	/**
-	* @see map
-	**/
-	sum(obj: any, map: string): number;
-
-	/**
-	* @see map
-	**/
-	sum(obj: any, map: (key: string, value: any) => number): number;
-
-	/**
-	* @see map
-	**/
-	average(obj: any, map: string): number;
-
-	/**
-	* @see map
-	**/
-	average(obj: any, map: (key: string, value: any) => number): number;
-
-	/**
-	* @see map
-	**/
-	min(obj: any, map: string): any;
-
-	/**
-	* @see map
-	**/
-	min(obj: any, map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	max(obj: any, map: string): any;
-
-	/**
-	* @see map
-	**/
-	max(obj: any, map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	least(obj: any, map: string): any;
-
-	/**
-	* @see map
-	**/
-	least(obj: any, map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	most(obj: any, map: string): any;
-
-	/**
-	* @see map
-	**/
-	most(obj: any, map: (key: string, value: any) => any): any;
-
-	/**
-	* Returns true if <a> and <b> are equal.
-	* @param a First object to compare.
-	* @param b Second object to compare.
-	* @returns True if the objects are equal, otherwise false.
-	* @extra %equal% in Sugar is "egal", meaning the values are equal
-	*        if they are "not observably distinguishable". Note that on
-	*        extended objects the name is %equals% for readability.
-	* @example
-	*   Object.equal({a:2}, {a:2}) -> true
-	*   Object.equal({a:2}, {a:3}) -> false
-	*   Object.extended({a:2}).equals({a:3}) -> false
-	**/
-	equal(a: any, b: any): boolean;
-
-	/**
-	* Checks if <obj> has <key> using hasOwnProperty from Object.prototype.
-	* @param obj Object to check for the property <key>.
-	* @param key Property to check to see if it exists on <obj>.
-	* @returns True if <key> exists on <obj>, otherwise false.
-	* @extra This method is considered safer than %Object#hasOwnProperty% when
-	*        using objects as hashes. See
-	*        http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/
-	*        for more.
-	* @example
-	*   Object.has({ foo: 'bar' }, 'foo') -> true
-	*   Object.has({ foo: 'bar' }, 'baz') -> false
-	*   Object.has({ hasOwnProperty: true }, 'foo') -> false
-	**/
-	has(obj: any, key: string): boolean;
-
-	/**
-	* Returns an array containing the keys in <obj>. Optionally calls [fn] for each key.
-	* @param obj Retreive all keys/properties from this object.
-	* @param fn Optional callback for each key/value pair.
-	* @returns Array of each property on <obj>.
-	* @extra This method is provided for browsers that don't support it natively,
-	*        and additionally is enhanced to accept the callback [fn]. Returned
-	*        keys are in no particular order. %keys% is available as an instance
-	*        method on extended objects.
-	* @example
-	*   Object.keys({ broken: 'wear' }) -> ['broken']
-	*   Object.keys({ broken: 'wear' }, function(key, value) {
-	*     // Called once for each key.
-	*   });
-	*   Object.extended({ broken: 'wear' }).keys() -> ['broken']
-	**/
-	keys(obj: any, fn?: (key: string, value: any) => void ): string[];
-
-	/**
-	* Merges all the properties of <source> into <target>.
-	* @param target
-	* @param source
-	* @param deep If true then deep merge, default = false.
-	* @param resolve If false then properties of source are used in the merge, default = true.
-	* @returns Merged object
-	* @extra Merges are shallow unless [deep] is %true%. Properties of <source>
-	*        will win in the case of conflicts, unless [resolve] is %false%.
-	*        [resolve] can also be a function that resolves the conflict.
-	*        In this case it will be passed 3 arguments, %key%, %targetVal%,
-	*        and %sourceVal%, with the context set to <source>. This will allow
-	*        you to solve conflict any way you want, ie. adding two numbers
-	*        together, etc. %merge% is available as an instance method on
-	*        extended objects.
-	* @example
-	*   Object.merge({a:1},{b:2}) -> { a:1, b:2 }
-	*   Object.merge({a:1},{a:2}, false, false) -> { a:1 }
-	+   Object.merge({a:1},{a:2}, false, function(key, a, b) {
-	*     return a + b;
-	*   }); -> { a:3 }
-	*   Object.extended({a:1}).merge({b:2}) -> { a:1, b:2 }
-	**/
-	merge(target: any, source: any, deep?: boolean, resolve?: boolean): any;
-
-	/**
-	* @see merge
-	* @param resolve Callback to resolve conflicts in the merge.
-	**/
-	merge(target: any, source: any, deep?: boolean, resolve?: (key: string, targetVal: any, sourceVal: any) => any): any;
-
-	/**
-	* Builds a new object containing all values except those specified in find.
-	* When find is a string, that single key will be rejected. It can also be a regex,
-	* rejecting any key that matches, or an object which will match if the key also
-	* exists in that object, effectively "subtracting" that object. Multiple selections
-	* may also be passed as an array or directly as enumerated arguments. reject is
-	* available as an instance method on extended objects.
-	* @param obj Object to remove the properties in `find`.
-	* @param find The property (string), properties (object) or RegExp to remove from `obj`.
-	* @return Modified `obj` with `find` properties removed.
-	**/
-	reject(obj: any, ...find: any[]): any;
-
-	/**
-	* Builds a new object containing the values specified in find. When find is a string,
-	* that single key will be selected. It can also be a regex, selecting any key that
-	* matches, or an object which will match if the key also exists in that object,
-	* effectively doing an "intersect" operation on that object. Multiple selections
-	* may also be passed as an array or directly as enumerated arguments. select is
-	* available as an instance method on extended objects.
-	* @param obj Object to keep the properties in `find`.
-	* @param find The property (string), properties (object) or RegExp to keep on `obj`.
-	* @return Modified `obj` with only the `find` properties remaining.
-	**/
-	select(obj: any, ...find: any[]): any;
-
-
-	/**
-	* Returns the number of properties in <obj>.
-	* @param obj Object to determine the number of properties on.
-	* @returns The number of properties on <obj>.
-	* @extra %size% is available as an instance method on extended objects.
-	* @example
-	*   Object.size({ foo: 'bar' }) -> 1
-	**/
-	size(obj: Object): number;
-
-	/**
-	* Runs <fn> and returns <obj>.
-	* @param obj Object to tap.
-	* @param fn Function to tap on <obj>.
-	* @returns <obj>
-	* @extra  A string can also be used as a shortcut to a method. This method
-	*         is used to run an intermediary function in the middle of method
-	*         chaining. As a standalone method on the Object class it doesn't
-	*         have too much use. The power of %tap% comes when using extended
-	*         objects or modifying the Object prototype with Object.extend().
-	* @example
-	*   Object.extend();
-	*   [2,4,6].map(Math.exp).tap(function(arr) {
-	*     arr.pop()
-	*   });
-	*   [2,4,6].map(Math.exp).tap('pop').map(Math.round); ->  [7,55]
-	**/
-	tap(obj: any, fn: string): any;
-
-	/**
-	* @see tap
-	**/
-	tap(obj: any, fn: (...args: any[]) => any): any;
-
-	/**
-	* Returns an array containing the values in <obj>.  Optionally calls [fn] for each value.
-	* @param obj Object to retrieve all values from.
-	* @param fn Optional callback for each value on <obj>.
-	* @returns Array
-	* @extra Returned values are in no particular order. %values% is available
-	*        as an instance method on extended objects.
-	* @example
-	*   Object.values({ broken: 'wear' }) -> ['wear']
-	*   Object.values({ broken: 'wear' }, function(value) {
-	*     // Called once for each value.
-	*   });
-	*   Object.extended({ broken: 'wear' }).values() -> ['wear']
-	**/
-	values(obj: any, fn?: (value: any) => any): any[];
-
-	/**
-	* Watches a property of <obj> and runs <fn> when it changes.
-	* @param obj Object to watch.
-	* @param prop Property to watch on <obj>
-	* @param fn Callback function when <prop> changes on <obj>.
-	* @extra <fn> is passed three arguments: the property <prop>, the old value,
-	*        and the new value. The return value of [fn] will be set as the new
-	*        value. This method is useful for things such as validating or cleaning
-	*        the value when it is set. Warning: this method WILL NOT work in
-	*        browsers that don't support %Object.defineProperty%. This notably
-	*        includes IE 8 and below, and Opera. This is the only method in Sugar
-	*        that is not fully compatible with all browsers. %watch% is available
-	*        as an instance method on extended objects.
-	* @example
-	*
-	*   Object.watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
-	*     // Will be run when the property 'foo' is set on the object.
-	*   });
-	*   Object.extended().watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
-	*     // Will be run when the property 'foo' is set on the object.
-	*   });
-	*
-	**/
-	watch(obj: any, prop: string, fn: (prop?: string, oldVal?: any, newVal?: any) => any): void;
-}
-
-interface Object {
-
-	/**
-	* Creates a new object, equivalent to %new Object()% or %{}%, but with extended methods.
-	* @returns Extended object.
-	* @extra See extended objects for more.
-	* @example
-	*   Object.extended()
-	*   Object.extended({ happy:true, pappy:false }).keys() -> ['happy','pappy']
-	*   Object.extended({ happy:true, pappy:false }).values() -> [true, false]
-	**/
-	extended(obj?: any): Object;
-
-	/**
-	* Returns true if <obj> is an object of that type.
-	* @method Object.is[Type](<obj>)
-	* @returns True if <obj> is of type [Type].
-	* @extra %isObject% will return false on anything that is not an object
-	*        literal, including instances of inherited classes. Note also
-	*        that %isNaN% will ONLY return true if the object IS %NaN%.
-	*        It does not mean the same as browser native %isNaN%, which returns
-	*        true for anything that is "not a number".
-	* @set
-	*   isArray
-	*   isObject
-	*   isBoolean
-	*   isDate
-	*   isFunction
-	*   isNaN
-	*   isNumber
-	*   isString
-	*   isRegExp
-	* @example
-	*   Object.isArray([1,2,3])            -> true
-	*   Object.isDate(3)                   -> false
-	*   Object.isRegExp(/wasabi/)          -> true
-	*   Object.isObject({ broken:'wear' }) -> true
-	**/
-	isArray(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isObject(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isBoolean(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isDate(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isFunction(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isNaN(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isNumber(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isString(): boolean;
-
-	/**
-	* @see isArray
-	**/
-	isRegExp(): boolean;
-
-	/**
-	* Converts the object into a query string. Accepts deep nested objects and arrays.
-	* If namespace is passed, it will be prefixed to all param names.
-	* @param obj Object to convert to a query string.
-	* @param namespace Namespace to prefix properties with in the query string.
-	* @return A query string generated from `obj` and `namespace`.
-	**/
-	toQueryString(namespace?: string): string;
-
-	/**
-	* Creates a clone (copy) of <obj>.
-	* @param deep If true then deep clone, default = false.
-	* @returns Cloned object.
-	* @extra Default is a shallow clone, unless [deep] is true. %clone%
-	*        is available as an instance method on extended objects.
-	* @example
-	*   Object.clone({foo:'bar'})            -> { foo: 'bar' }
-	*   Object.clone()                       -> {}
-	*   Object.extended({foo:'bar'}).clone() -> { foo: 'bar' }
-	**/
-	clone(deep?: boolean): any;
-
-	/**
-	* Enumerable methods in the Array package are also available to
-	*        the Object class. They will perform their normal operations for
-	*        every property in <obj>.
-	* @method [enumerable](<obj>)
-	* @returns Boolean
-	* @extra In cases where a callback is used, instead of %element, index%,
-	*        the callback will instead be passed %key, value%. Enumerable methods
-	*        are also available to extended objects as instance methods.
-	* @set
-	*   each
-	*   map
-	*   any
-	*   all
-	*   none
-	*   count
-	*   find
-	*   findAll
-	*   reduce
-	*   isEmpty
-	*   sum
-	*   average
-	*   min
-	*   max
-	*   least
-	*   most
-	* @example
-	*   Object.any({foo:'bar'}, 'bar')            -> true
-	*   Object.extended({foo:'bar'}).any('bar')   -> true
-	*   Object.isEmpty({})                        -> true
-	*   Object.map({ fred: { age: 52 } }, 'age'); -> { fred: 52 }
-	**/
-	map<U>(map: string): U;
-
-	/**
-	* @see map
-	**/
-	map<U>(map: (key: string, value: any) => any): U;
-
-	/**
-	* @see map
-	**/
-	any(map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	any(map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	all(map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	all(map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	none(map: string): boolean;
-
-	/**
-	* @see map
-	**/
-	none(map: (key: string, value: any) => boolean): boolean;
-
-	/**
-	* @see map
-	**/
-	count(map: string): number;
-
-	/**
-	* @see map
-	**/
-	count(map: (key: string, value: any) => boolean): number;
-
-	/**
-	* @see map
-	**/
-	find(map: string): any;
-
-	/**
-	* @see map
-	**/
-	find(map: (key: string, value: any) => boolean): any;
-
-	/**
-	* @see map
-	**/
-	findAll(map: string): any[];
-
-	/**
-	* @see map
-	**/
-	findAll(map: (key: string, value: any) => boolean): any[];
-
-	/**
-	* @see map
-	**/
-	reduce(map: string, init?: any): any;
-
-	/**
-	* @see map
-	**/
-	reduce(map: (key: string, value: any) => any, init?: any): any;
-
-	/**
-	* @see map
-	**/
-	isEmpty(): boolean;
-
-	/**
-	* @see map
-	**/
-	sum(map: string): number;
-
-	/**
-	* @see map
-	**/
-	sum(map: (key: string, value: any) => number): number;
-
-	/**
-	* @see map
-	**/
-	average(map: string): number;
-
-	/**
-	* @see map
-	**/
-	average(map: (key: string, value: any) => number): number;
-
-	/**
-	* @see map
-	**/
-	min(map: string): any;
-
-	/**
-	* @see map
-	**/
-	min(map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	max(map: string): any;
-
-	/**
-	* @see map
-	**/
-	max(map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	least(map: string): any;
-
-	/**
-	* @see map
-	**/
-	least(map: (key: string, value: any) => any): any;
-
-	/**
-	* @see map
-	**/
-	most(map: string): any;
-
-	/**
-	* @see map
-	**/
-	most(map: (key: string, value: any) => any): any;
-
-	/**
-	* Returns true if <a> and <b> are equal.
-	* @param b Compare to this object
-	* @returns True if the objects are equal, otherwise false.
-	* @extra %equal% in Sugar is "egal", meaning the values are equal
-	*        if they are "not observably distinguishable". Note that on
-	*        extended objects the name is %equals% for readability.
-	* @example
-	*   Object.equal({a:2}, {a:2}) -> true
-	*   Object.equal({a:2}, {a:3}) -> false
-	*   Object.extended({a:2}).equals({a:3}) -> false
-	**/
-	equal(b: any): boolean;
-
-	/**
-	* Checks if <obj> has <key> using hasOwnProperty from Object.prototype.
-	* @param key Property to check to see if it exists on <obj>.
-	* @returns True if <key> exists on <obj>, otherwise false.
-	* @extra This method is considered safer than %Object#hasOwnProperty% when
-	*        using objects as hashes. See
-	*        http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/
-	*        for more.
-	* @example
-	*   Object.has({ foo: 'bar' }, 'foo') -> true
-	*   Object.has({ foo: 'bar' }, 'baz') -> false
-	*   Object.has({ hasOwnProperty: true }, 'foo') -> false
-	**/
-	has(key: string): boolean;
-
-	/**
-	* Returns an array containing the keys in <obj>. Optionally calls [fn] for each key.
-	* @param fn Optional callback for each key/value pair.
-	* @returns Array of each property on <obj>.
-	* @extra This method is provided for browsers that don't support it natively,
-	*        and additionally is enhanced to accept the callback [fn]. Returned
-	*        keys are in no particular order. %keys% is available as an instance
-	*        method on extended objects.
-	* @example
-	*   Object.keys({ broken: 'wear' }) -> ['broken']
-	*   Object.keys({ broken: 'wear' }, function(key, value) {
-	*     // Called once for each key.
-	*   });
-	*   Object.extended({ broken: 'wear' }).keys() -> ['broken']
-	**/
-	keys(fn?: (key: string, value: any) => void ): string[];
-
-	/**
-	* Merges all the properties of <source> into <target>.
-	* @param source
-	* @param deep If true then deep merge, default = false.
-	* @param resolve If false then properties of source are used in the merge, default = true.
-	* @returns Merged object
-	* @extra Merges are shallow unless [deep] is %true%. Properties of <source>
-	*        will win in the case of conflicts, unless [resolve] is %false%.
-	*        [resolve] can also be a function that resolves the conflict.
-	*        In this case it will be passed 3 arguments, %key%, %targetVal%,
-	*        and %sourceVal%, with the context set to <source>. This will allow
-	*        you to solve conflict any way you want, ie. adding two numbers
-	*        together, etc. %merge% is available as an instance method on
-	*        extended objects.
-	* @example
-	*   Object.merge({a:1},{b:2}) -> { a:1, b:2 }
-	*   Object.merge({a:1},{a:2}, false, false) -> { a:1 }
-	+   Object.merge({a:1},{a:2}, false, function(key, a, b) {
-	*     return a + b;
-	*   }); -> { a:3 }
-	*   Object.extended({a:1}).merge({b:2}) -> { a:1, b:2 }
-	**/
-	merge(source: any, deep?: boolean, resolve?: boolean): any;
-
-	/**
-	* @see merge
-	* @param resolve Callback to resolve conflicts in the merge.
-	**/
-	merge(source: any, deep?: boolean, resolve?: (key: string, targetVal: any, sourceVal: any) => any): any;
-
-	/**
-	* Builds a new object containing all values except those specified in find.
-	* When find is a string, that single key will be rejected. It can also be a regex,
-	* rejecting any key that matches, or an object which will match if the key also
-	* exists in that object, effectively "subtracting" that object. Multiple selections
-	* may also be passed as an array or directly as enumerated arguments. reject is
-	* available as an instance method on extended objects.
-	* @param find The property (string), properties (object) or RegExp to remove from `obj`.
-	* @return Modified `obj` with `find` properties removed.
-	**/
-	reject(...find: any[]): any;
-
-	/**
-	* Builds a new object containing the values specified in find. When find is a string,
-	* that single key will be selected. It can also be a regex, selecting any key that
-	* matches, or an object which will match if the key also exists in that object,
-	* effectively doing an "intersect" operation on that object. Multiple selections
-	* may also be passed as an array or directly as enumerated arguments. select is
-	* available as an instance method on extended objects.
-	* @param find The property (string), properties (object) or RegExp to keep on `obj`.
-	* @return Modified `obj` with only the `find` properties remaining.
-	**/
-	select(...find: any[]): any;
-
-
-	/**
-	* Returns the number of properties in <obj>.
-	* @returns The number of properties on <obj>.
-	* @extra %size% is available as an instance method on extended objects.
-	* @example
-	*   Object.size({ foo: 'bar' }) -> 1
-	**/
-	size(): number;
-
-	/**
-	* Runs <fn> and returns <obj>.
-	* @param fn Function to tap on <obj>.
-	* @returns <obj>
-	* @extra  A string can also be used as a shortcut to a method. This method
-	*         is used to run an intermediary function in the middle of method
-	*         chaining. As a standalone method on the Object class it doesn't
-	*         have too much use. The power of %tap% comes when using extended
-	*         objects or modifying the Object prototype with Object.extend().
-	* @example
-	*   Object.extend();
-	*   [2,4,6].map(Math.exp).tap(function(arr) {
-	*     arr.pop()
-	*   });
-	*   [2,4,6].map(Math.exp).tap('pop').map(Math.round); ->  [7,55]
-	**/
-	tap(fn: string): any;
-
-	/**
-	* @see tap
-	**/
-	tap(fn: (...args: any[]) => any): any;
-
-	/**
-	* Returns an array containing the values in <obj>.  Optionally calls [fn] for each value.
-	* @param fn Optional callback for each value on <obj>.
-	* @returns Array
-	* @extra Returned values are in no particular order. %values% is available
-	*        as an instance method on extended objects.
-	* @example
-	*   Object.values({ broken: 'wear' }) -> ['wear']
-	*   Object.values({ broken: 'wear' }, function(value) {
-	*     // Called once for each value.
-	*   });
-	*   Object.extended({ broken: 'wear' }).values() -> ['wear']
-	**/
-	values(fn?: (value: any) => any): any[];
-
-	/**
-	* Watches a property of <obj> and runs <fn> when it changes.
-	* @param obj Object to watch.
-	* @param prop Property to watch on <obj>
-	* @param fn Callback function when <prop> changes on <obj>.
-	* @extra <fn> is passed three arguments: the property <prop>, the old value,
-	*        and the new value. The return value of [fn] will be set as the new
-	*        value. This method is useful for things such as validating or cleaning
-	*        the value when it is set. Warning: this method WILL NOT work in
-	*        browsers that don't support %Object.defineProperty%. This notably
-	*        includes IE 8 and below, and Opera. This is the only method in Sugar
-	*        that is not fully compatible with all browsers. %watch% is available
-	*        as an instance method on extended objects.
-	* @example
-	*
-	*   Object.watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
-	*     // Will be run when the property 'foo' is set on the object.
-	*   });
-	*   Object.extended().watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
-	*     // Will be run when the property 'foo' is set on the object.
-	*   });
-	*
-	**/
-	watch(prop: string, fn: (prop?: string, oldVal?: any, newVal?: any) => any): void;
-}
-
-interface Function {
-
-	/**
-	* Creates a function that will execute after [num] calls.
-	* @param num Execute the function after this many calls, default = 1.
-	* @returns Function that can only execute after it has been called <num> times.
-	* @extra %after% is useful for running a final callback after a series of
-	*        asynchronous operations, when the order in which the operations will
-	*        complete is unknown.
-	* @example
-	*   var fn = (function() {
-	*     // Will be executed once only
-	*   }).after(3); fn(); fn(); fn();
-	**/
-	after(num?: number): Function;
-
-	/**
-	* Binds <scope> as the %this% object for the function when it is called.
-	*        Also allows currying an unlimited number of parameters.
-	* @param scope this object during the function call.
-	* @param args Curried parameters.
-	* @returns Function with bound 'this' and curried parameters.
-	* @extra "currying" means setting parameters ([arg1], [arg2], etc.) ahead of
-	*         time so that they are passed when the function is called later.
-	*         If you pass additional parameters when the function is actually
-	*         called, they will be added will be added to the end of the curried
-	*         parameters. This method is provided for browsers that don't support
-	*         it internally.
-	* @example
-	*   (function() {
-	*     return this;
-	*   }).bind('woof')(); -> returns 'woof'; function is bound with 'woof' as the this object.
-	*   (function(a) {
-	*     return a;
-	*   }).bind(1, 2)();   -> returns 2; function is bound with 1 as the this object and 2 curried as the first parameter
-	*   (function(a, b) {
-	*     return a + b;
-	*   }).bind(1, 2)(3);  -> returns 5; function is bound with 1 as the this object, 2 curied as the first parameter and 3 passed as the second when calling the function
-	**/
-	bind(scope?: any, ...args: any[]): Function;
-
-	/**
-	* Cancels a delayed function scheduled to be run.
-	* @returns Function
-	* @extra %delay%, %lazy%, %throttle%, and %debounce% can all set delays.
-	* @example
-	*   (function() {
-	*     alert('hay'); // Never called
-	*   }).delay(500).cancel();
-	**/
-	cancel(): Function;
-
-	/**
-	* Creates a "debounced" function that postpones its execution until after <ms> milliseconds have passed.
-	* @param ms Number of milliseconds to debounce the function.
-	* @returns Deboucned function by ms <ms>.
-	* @extra This method is useful to execute a function after things have
-	*        "settled down". A good example of this is when a user tabs quickly
-	*        through form fields, execution of a heavy operation should happen
-	*        after a few milliseconds when they have "settled" on a field.
-	* @example
-	*   var fn = (function(arg1) {
-	*     // called once 50ms later
-	*   }).debounce(50); fn() fn() fn();
-	**/
-	debounce(ms: number): Function;
-
-	/**
-	* Executes the function after <ms> milliseconds.
-	* @param ms Milliseconds to delay execution, default = 0.
-	* @param args Additional arguments.
-	* @returns Reference to itself.
-	* @extra Returns a reference to itself. %delay% is also a way to execute
-	*        non-blocking operations that will wait until the CPU is free.
-	*        Delayed functions can be canceled using the %cancel% method.
-	*        Can also curry arguments passed in after <ms>.
-	* @example
-	*   (function(arg1) {
-	*     // called 1s later
-	*   }).delay(1000, 'arg1');
-	**/
-	delay(ms?: number, ...args: any[]): Function;
-
-	/**
-	* Returns a new version of the function which when called will have
-	*        some of its arguments pre-emptively filled in, also known as "currying".
-	* @param args Pre-filled arguments.
-	* @returns Function with pre-filled arguments.
-	* @extra Arguments passed to a "filled" function are generally appended to
-	*        the curried arguments. However, if %undefined% is passed as any of
-	*        the arguments to %fill%, it will be replaced, when the "filled"
-	*        function is executed. This allows currying of arguments even when
-	*        they occur toward the end of an argument list (the example
-	*        demonstrates this much more clearly).
-	* @example
-	*   var delayOneSecond = setTimeout.fill(undefined, 1000);
-	*   delayOneSecond(function() {
-	*     // Will be executed 1s later
-	*   });
-	**/
-	fill(...args: any[]): Function;
-
-	/**
-	* Creates a lazy function that, when called repeatedly, will queue execution and wait [ms] milliseconds to execute again.
-	* @method lazy([ms] = 1, [limit] = Infinity)
-	* @param ms Wait this long between successive calls, default = 1.
-	* @param limit Maximum number of times the function can execute, default = Infinity.
-	* @returns Function
-	* @extra Lazy functions will always execute as many times as they are called
-	*        up to [limit], after which point subsequent calls will be ignored
-	*        (if it is set to a finite number). Compare this to %throttle%, which
-	*        will execute only once per [ms] milliseconds. %lazy% is useful when
-	*        you need to be sure that every call to a function is executed, but
-	*        in a non-blocking manner. Calling %cancel% on a lazy function will
-	*       clear the entire queue. Note that [ms] can also be a fraction.
-	* @example
-	*   (function() {
-	*     // Executes immediately.
-	*   }).lazy()();
-	*   (3).times(function() {
-	*     // Executes 3 times, with each execution 20ms later than the last.
-	*   }.lazy(20));
-	*   (100).times(function() {
-	*     // Executes 50 times, with each execution 20ms later than the last.
-	*   }.lazy(20, 50));
-	**/
-	lazy(ms?: number, limit?: number): Function;
-
-	/**
-	* Creates a function that will execute only once and store the result.
-	* @returns Function
-	* @extra %once% is useful for creating functions that will cache the result of
-	*        an expensive operation and use it on subsequent calls. Also it can be
-	*        useful for creating initialization functions that only need to be run
-	*        once.
-	* @example
-	*   var fn = (function() {
-	*     // Will be executed once only
-	*   }).once(); fn(); fn(); fn();
-	**/
-	once(): Function;
-
-	/**
-	* Creates a "throttled" version of the function that will only be executed once per <ms> milliseconds.
-	* @param ms Execute only once in this time span.
-	* @returns Function
-	* @extra This is functionally equivalent to calling %lazy% with a [limit]
-	*        of %1%. %throttle% is appropriate when you want to make sure a
-	*        function is only executed at most once for a given duration.
-	*        Compare this to %lazy%, which will queue rapid calls and execute
-	*        them later.
-	* @example
-	*   (3).times(function() {
-	*     // called only once. will wait 50ms until it responds again
-	*   }.throttle(50));
-	**/
-	throttle(ms: number): Function;
-}
-
-interface RegExpConstructor {
-
-	/**
-	* Escapes all RegExp tokens in a string.
-	* @param str Escape RegExp tokens in this string.
-	* @returns Escaped RegExp tokens in <str>.
-	* @example
-	*   RegExp.escape('really?')      -> 'really\?'
-	*   RegExp.escape('yes.')         -> 'yes\.'
-	*   RegExp.escape('(not really)') -> '\(not really\)'
-	**/
-	escape(str: string): string;
-}
-
-interface RegExp {
-
-	/**
-	* Adds <flag> to the regex.
-	* @param flag RegExp flag to add.
-	* @returns RegExp with <flag> added.
-	* @example
-	*   /texty/.addFlag('g') -> now has global flag set
-	**/
-	addFlag(flag: string): RegExp;
-
-	/**
-	* Returns the flags of the regex as a string.
-	* @returns RegExp flags.
-	* @example
-	*   /texty/gim.getFlags('testy') -> 'gim'
-	**/
-	getFlags(): string;
-
-	/**
-	* Removes <flag> from the regex.
-	* @param flag RegExp flag to remove.
-	* @returns RegExp with flag <flag> removed.
-	* @example
-	*   /texty/g.removeFlag('g') -> now has global flag removed
-	**/
-	removeFlag(flag: string): RegExp;
-
-	/**
-	* Sets the flags on a regex and retuns a copy.
-	* @param flags Set the RegExp to have these flags.
-	* @returns Copy of RegExp with <flags>.
-	* @example
-	*   /texty/.setFlags('gim') -> now has global, ignoreCase, and multiline set
-	**/
-	setFlags(flags: string): RegExp;
-}
-
-interface Locale {
-	plural: boolean;
-	months: string;
-	weekdays: string;
-	units: string;
-	numbers: string;
-	tokens: string[];
-	short: string;
-	long: string;
-	full: string;
-	past: string;
-	future: string;
-	duration: string;
-	timeMarker: string;
-	ampm: string;
-	modifiers:
-		{
-			name: string;
-			src: string;
-			value: number;
-		}[];
-	dateParse: string[];
-	timeParse: string[];
-}
-
-interface DateConstructor {
-
-	/**
-	* Adds a locale <set> to the locales understood by Sugar.
-	* @method Date.addLocale(<code>, <set>)
-	* @param code Locale code.
-	* @param set Locale definition.
-	* @returns Locale
-	* @extra For more see @date_format.
-	**/
-	addLocale(code: string, set: Locale): Locale;
-
-	/**
-	* Alternate Date constructor which understands many different text formats,
-	*        a timestamp, or another date.
-	* @method Date.create(<d>, [locale] = currentLocale)
-	* @param locale Locale to create the date in, default = currentLocale.
-	* @returns Date
-	* @extra If no argument is given, date is assumed to be now. %Date.create% additionally
-	*        can accept enumerated parameters as with the standard date constructor. [locale]
-	*        can be passed to specify the locale that the date is in. When unspecified, the
-	*        current locale (default is English) is assumed. UTC-based dates can be created
-	*        through the %utc% object. For more see @date_format.
-	* @set
-	*   Date.utc.create
-	* @example
-	*   Date.create('July')          -> July of this year
-	*   Date.create('1776')          -> 1776
-	*   Date.create('today')         -> today
-	*   Date.create('wednesday')     -> This wednesday
-	*   Date.create('next friday')   -> Next friday
-	*   Date.create('July 4, 1776')  -> July 4, 1776
-	*   Date.create(-446806800000)   -> November 5, 1955
-	*   Date.create(1776, 6, 4)      -> July 4, 1776
-	*   Date.create('1776?07?04?', 'ja') -> July 4, 1776
-	*   Date.utc.create('July 4, 1776', 'en')  -> July 4, 1776
-	**/
-	create(locale?: string): Date;
-
-	/**
-	* @see create
-	* @param d Human readable date to convert to a Date object.
-	**/
-	create(d: string, locale?: string): Date;
-
-	/**
-	* @see create
-	* @param timestamp 	
-	create(timestamp?: number): Date;
-
-	/**
-	* @see create
-	* @param year Year YYYY
-	* @param month Month MM
-	* @param day Day DD
-	**/
-	create(year: number, month: number, day: number, locale?: string): Date;
-
-	/**
-	* Alternate form of %Date.create% with any ambiguity assumed to be the future.
-	* @method Date.future(<d>, [locale] = currentLocale)
-	* @param d Future human redable date to convert to a Date object.
-	* @param locale Locale to create the date in, default = currentLocale.
-	* @returns Date
-	* @extra For example %"Sunday"% can be either "the Sunday coming up" or "the Sunday last"
-	*        depending on context. Note that dates explicitly in the past ("last Sunday") will
-	*        remain in the past. This method simply provides a hint when ambiguity exists. UTC
-	*       -based dates can be created through the %utc% object. For more, see @date_format.
-	* @set
-	*   Date.utc.future
-	* @example
-	*   Date.future('July')          -> July of this year or next depending on the current month
-	*   Date.future('Wednesday')     -> This wednesday or next depending on the current weekday
-	**/
-	future(d: string, locale?: string): Date;
-
-	/**
-	* Gets the locale for the given code, or the current locale.
-	* @method Date.getLocale([code] = current)
-	* @param code Locale code to retrieve.
-	* @returns Locale
-	* @extra The resulting locale object can be manipulated to provide more control over date localizations.
-	*        For more about locales, see @date_format.
-	**/
-	getLocale(code?: string): Locale;
-
-	/**
-	* Returns the number of milliseconds since January 1st, 1970 00:00:00 (UTC time).
-	* @method Date.now()
-	* @returns String
-	* @extra Provided for browsers that do not support this method.
-	* @example
-	*   Date.now() -> ex. 1311938296231
-	**/
-	now(): number;
-
-	/**
-	* Alternate form of %Date.create% with any ambiguity assumed to be the past.
-	* @method Date.past(<d>, [locale] = currentLocale)
-	* @param d Past human readable date to convert to a Date object.
-	* @param locale , default = currentLocale.
-	* @returns Date
-	* @extra For example %"Sunday"% can be either "the Sunday coming up" or "the Sunday last" depending
-	*        on context. Note that dates explicitly in the future ("next Sunday") will remain in the future.
-	*        This method simply provides a hint when ambiguity exists. UTC-based dates can be created
-	*        through the %utc% object. For more, see @date_format.
-	* @set
-	*   Date.utc.past
-	* @example
-	*   Date.past('July')          -> July of this year or last depending on the current month
-	*   Date.past('Wednesday')     -> This wednesday or last depending on the current weekday
-	**/
-	past(d: string, local?: string): Date;
-
-	/**
-	* Creates a new date range.
-	* @method Date.range([start], [end])
-	* @param start Beginning date.
-	* @param end Ending date.
-	* @returns DateRange
-	* @extra If either [start] or [end] are null, they will default to the current date.
-	**/
-	range(start: Date, end: Date): DateRange;
-
-	/**
-	* Sets the current locale to be used with dates.
-	* @method Date.setLocale(<code>)
-	* @param code Locale code.
-	* @returns Locale
-	* @extra Sugar has support for 13 locales that are available through the
-	*        "Date Locales" package. In addition you can define a new locale with
-	*         %Date.addLocale%. For more see @date_format.
-	**/
-	setLocale(code: string): Locale;
-}
-
-interface DateFields {
-	year?: number;
-	month?: number;
-	day?: number;
-}
-
-interface Date {
-
-	/**
-	* Adds <num> of the unit to the date. If [reset] is true, all lower units will be reset.
-	* @method add[Units](<num>, [reset] = false)
-	* @param num Add this many [Units] to the date.
-	* @param reset If true lower units will be reset.
-	* @returns Date
-	* @extra Note that "months" is ambiguous as a unit of time. If the target
-	*        date falls on a day that does not exist (ie. August 31 -> February 31),
-	*        the date will be shifted to the last day of the month. Don't use
-	*        %addMonths% if you need precision.
-	* @set
-	*   addMilliseconds
-	*   addSeconds
-	*   addMinutes
-	*   addHours
-	*   addDays
-	*   addWeeks
-	*   addMonths
-	*   addYears
-	* @example
-	*   Date.create().addMilliseconds(5) -> current time + 5 milliseconds
-	*   Date.create().addDays(5)         -> current time + 5 days
-	*   Date.create().addYears(5)        -> current time + 5 years
-	**/
-	addMilliseconds(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addSeconds(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addMinutes(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addHours(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addDays(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addWeeks(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addMonths(num: number, reset?: boolean): Date;
-
-	/**
-	* @see addMilliseconds
-	**/
-	addYears(num: number, reset?: boolean): Date;
-
-	/**
-	* Sets the date forward.
-	* @method advance(<set>, [reset] = false)
-	* @param set Human readable amount of time to advance the date.
-	* @param reset If true resets the lower date fields to zero.
-	* @returns Date
-	* @extra This method can accept multiple formats including an object, a string
-	*        in the format %3 days%, a single number as milliseconds, or enumerated
-	*        parameters (as with the Date constructor). If [reset] is %true%, any
-	*        units more specific than those passed will be reset. For more see
-	*        @date_format.
-	* @example
-	*   new Date().advance({ year: 2 }) -> 2 years in the future
-	*   new Date().advance('2 days')    -> 2 days in the future
-	*   new Date().advance(0, 2, 3)     -> 2 months 3 days in the future
-	*   new Date().advance(86400000)    -> 1 day in the future
-	**/
-	advance(set: string, reset?: boolean): Date;
-
-	/**
-	* @see advance
-	* @param year YYYY to advance.
-	* @param month MM to advance.
-	* @param day DD to advance.
-	**/
-	advance(year: number, month: number, day: number, reset?: boolean): Date;
-
-	/**
-	* @see advance
-	* @param milliseconds Milliseconds to advance the date.
-	**/
-	advance(milliseconds: number, reset?: boolean): Date;
-
-	/**
-	* @see advance
-	* @param set Advance the year/month/day of the date from a single object.
-	**/
-	advance(set: DateFields, reset?: boolean): Date;
-
-	/**
-	* Sets the date to the beginning of the appropriate unit.
-	* @method beginningOf[Unit]()
-	* @returns Date
-	* @set
-	*   beginningOfDay
-	*   beginningOfWeek
-	*   beginningOfMonth
-	*   beginningOfYear
-	* @example
-	*   Date.create().beginningOfDay()   -> the beginning of today (resets the time)
-	*   Date.create().beginningOfWeek()  -> the beginning of the week
-	*   Date.create().beginningOfMonth() -> the beginning of the month
-	*   Date.create().beginningOfYear()  -> the beginning of the year
-	**/
-	beginningOfDay(): Date;
-	beginningOfWeek(): Date;
-	beginningOfMonth(): Date;
-	beginningOfYear(): Date;
-
-	/**
-	* Clones the date.
-	* @method clone()
-	* @returns Date
-	* @example
-	*   Date.create().clone() -> Copy of now
-	**/
-	clone(): Date;
-
-	/**
-	* Returns the number of days in the date's month.
-	* @method daysInMonth()
-	* @returns Number
-	* @example
-	*   Date.create('May').daysInMonth()            -> 31
-	*   Date.create('February, 2000').daysInMonth() -> 29
-	**/
-	daysInMonth(): number;
-
-	/**
-	* Sets the date to the end of the appropriate unit.
-	* @method endOf[Unit]()
-	* @returns Date
-	* @set
-	*   endOfDay
-	*   endOfWeek
-	*   endOfMonth
-	*   endOfYear
-	* @example
-	*   Date.create().endOfDay()   -> the end of today (sets the time to 23:59:59.999)
-	*   Date.create().endOfWeek()  -> the end of the week
-	*   Date.create().endOfMonth() -> the end of the month
-	*   Date.create().endOfYear()  -> the end of the year
-	**/
-	endOfDay(): Date;
-	endOfWeek(): Date;
-	endOfMonth(): Date;
-	endOfYear(): Date;
-
-	/**
-	* Formats and outputs the date.
-	* @method format(<format>, [locale] = currentLocale)
-	* @returns String
-	* @extra <format> can be a number of pre-determined formats or a string of
-	*        tokens. Locale-specific formats are %short%, %long%, and %full% which
-	*        have their own aliases and can be called with %date.short()%, etc.
-	*        If <format> is not specified the %long% format is assumed. [locale]
-	*        specifies a locale code to use (if not specified the current locale
-	*        is used). See @date_format for more details.
-	* @set
-	*   short
-	*   long
-	*   full
-	* @example
-	*   Date.create().format()                                   -> ex. July 4, 2003
-	*   Date.create().format('{Weekday} {d} {Month}, {yyyy}')    -> ex. Monday July 4, 2003
-	*   Date.create().format('{hh}:{mm}')                        -> ex. 15:57
-	*   Date.create().format('{12hr}:{mm}{tt}')                  -> ex. 3:57pm
-	*   Date.create().format(Date.ISO8601_DATETIME)              -> ex. 2011-07-05 12:24:55.528Z
-	*   Date.create('last week').format('short', 'ja')                -> ex. ??
-	*   Date.create('yesterday').format(function(value,unit,ms,loc) {
-	*     // value = 1, unit = 3, ms = -86400000, loc = [current locale object]
-	*   });                                                      -> ex. 1 day ago
-	**/
-	format(format: string, locale?: string): string;
-    	short(locale?: string): string;
-    	long(locale?: string): string;
-    	full(locale?: string): string;
-
-	/**
-	* Returns a string representation of the offset from UTC time. If [iso]
-	*        is true the offset will be in ISO8601 format.
-	* @method getUTCOffset([iso])
-	* @returns String
-	* @example
-	*   new Date().getUTCOffset()     -> "+0900"
-	*   new Date().getUTCOffset(true) -> "+09:00"
-	**/
-	getUTCOffset(iso?: boolean): string;
-
-	/**
-	* Gets the date's week (of the year).
-	* @returns The date's week of the year as defined by the ISO-8601 standard.
-	* @extra If %utc% is set on the date, the week will be according to UTC time.
-	* @example
-	*   new Date().getWeek()    -> today's week of the year
-	**/
-	getISOWeek(): number;
-
-	/**
-	* Alias for %getDay%.
-	* @method getWeekday()
-	* @returns Number
-	* @set
-	*   getUTCWeekday
-	* @example
-	*   Date.create().getWeekday();    -> (ex.) 3
-	*   Date.create().getUTCWeekday();    -> (ex.) 3
-	**/
-	getWeekday(): number;
-	getUTCWeekday(): number;
-	//getDay(): number;
-	//getUTCDay(): number;
-
-	/**
-	* Returns true if the date is <d>.
-	* @method is(<d>, [margin] = 0)
-	* @returns Boolean
-	* @extra <d> will accept a date object, timestamp, or text format. %is%
-	*        additionally understands more generalized expressions like
-	*        month/weekday names, 'today', etc, and compares to the precision
-	*        implied in <d>. [margin] allows an extra margin of error in
-	*        milliseconds.  For more, see @date_format.
-	* @example
-	*   Date.create().is('July')               -> true or false?
-	*   Date.create().is('1776')               -> false
-	*   Date.create().is('today')              -> true
-	*   Date.create().is('weekday')            -> true or false?
-	*   Date.create().is('July 4, 1776')       -> false
-	*   Date.create().is(-6106093200000)       -> false
-	*   Date.create().is(new Date(1776, 6, 4)) -> false
-	**/
-	is(d: string, margin?: number): boolean;
-	is(milliseconds: number, margin?: number): boolean;
-	is(d: Date, margin?: number): boolean;
-
-	/**
-	* Returns true if the date is after the <d>.
-	* @method isAfter(<d>, [margin] = 0)
-	* @returns Boolean
-	* @extra [margin] is to allow extra margin of error (in ms). <d> will accept
-	*        a date object, timestamp, or text format. If not specified, <d> is
-	*        assumed to be now. See @date_format for more.
-	* @example
-	*   new Date().isAfter('tomorrow')  -> false
-	*   new Date().isAfter('yesterday') -> true
-	**/
-	isAfter(d: string, margin?: number): boolean;
-	isAfter(milliseconds: number, margin?: number): boolean;
-	isAfter(d: Date, margin?: number): boolean;
-
-	/**
-	* Returns true if the date is before <d>.
-	* @method isBefore(<d>, [margin] = 0)
-	* @returns Boolean
-	* @extra [margin] is to allow extra margin of error (in ms). <d> will accept
-	*        a date object, timestamp, or text format. If not specified, <d> is
-	*        assumed to be now. See @date_format for more.
-	* @example
-	*   new Date().isBefore('tomorrow')  -> true
-	*   new Date().isBefore('yesterday') -> false
-	**/
-	isBefore(d: string, margin?: number): boolean;
-	isBefore(milliseconds: number, margin?: number): boolean;
-	isBefore(d: Date, margin?: number): boolean;
-
-	/**
-	* Returns true if the date falls between <d1> and <d2>.
-	* @method isBetween(<d1>, <d2>, [margin] = 0)
-	* @returns Boolean
-	* @extra [margin] is to allow extra margin of error (in ms). <d1> and <d2>
-	*        will accept a date object, timestamp, or text format. If not specified,
-	*        they are assumed to be now. See @date_format for more.
-	* @example
-	*   new Date().isBetween('yesterday', 'tomorrow')    -> true
-	*   new Date().isBetween('last year', '2 years ago') -> false
-	**/
-	isBefore(start: string, end: string, margin?: number): boolean;
-	isBefore(start: number, end: string, margin?: number): boolean;
-	isBefore(start: Date, end: Date, margin?: number): boolean;
-
-	/**
-	* Returns true if the date falls on that day.
-	* @method is[Day]()
-	* @returns Boolean
-	* @extra Also available: %isYesterday%, %isToday%, %isTomorrow%, %isWeekday%,
-	*        and %isWeekend%.
-	* @set
-	*   isToday
-	*   isYesterday
-	*   isTomorrow
-	*   isWeekday
-	*   isWeekend
-	*   isSunday
-	*   isMonday
-	*   isTuesday
-	*   isWednesday
-	*   isThursday
-	*   isFriday
-	*   isSaturday
-	* @example
-	*   Date.create('tomorrow').isToday() -> false
-	*   Date.create('thursday').isTomorrow() -> ?
-	*   Date.create('yesterday').isWednesday() -> ?
-	*   Date.create('today').isWeekend() -> ?
-	**/
-	isToday(): boolean;
-	isYesterday(): boolean;
-	isTomorrow(): boolean;
-	isWeekday(): boolean;
-	isWeekend(): boolean;
-	isSunday(): boolean;
-	isMonday(): boolean;
-	isTuesday(): boolean;
-	isWednesday(): boolean;
-	isThursday(): boolean;
-	isFriday(): boolean;
-	isSaturday(): boolean;
-
-	/**
-	* Returns true if the date is in the future.
-	* @method isFuture()
-	* @returns Boolean
-	* @example
-	*   Date.create('next week').isFuture() -> true
-	*   Date.create('last week').isFuture() -> false
-	**/
-	isFuture(): boolean;
-
-	/**
-	* Returns true if the date is last week/month/year.
-	* @method isLast[Unit]()
-	* @returns Boolean
-	* @set
-	*   isLastWeek
-	*   isLastMonth
-	*   isLastYear
-	* @example
-	*   Date.create('yesterday').isLastWeek()  -> true or false?
-	*   Date.create('yesterday').isLastMonth() -> probably not...
-	*   Date.create('yesterday').isLastYear()  -> even less likely...
-	**/
-	isLastWeek(): boolean;
-	isLastMonth(): boolean;
-	isLastYear(): boolean;
-
-	/**
-	* Returns true if the date is a leap year.
-	* @method isLeapYear()
-	* @returns Boolean
-	* @example
-	*   Date.create('2000').isLeapYear() -> true
-	**/
-	isLeapYear(): boolean;
-
-	/**
-	* Returns true if the date is next week/month/year.
-	* @method isNext[Unit]()
-	* @returns Boolean
-	* @set
-	*   isNextWeek
-	*   isNextMonth
-	*   isNextYear
-	* @example
-	*   Date.create('tomorrow').isNextWeek()  -> true or false?
-	*   Date.create('tomorrow').isNextMonth() -> probably not...
-	*   Date.create('tomorrow').isNextYear()  -> even less likely...
-	**/
-	isNextWeek(): boolean;
-	isNextMonth(): boolean;
-	isNextYear(): boolean;
-
-	/**
-	* Returns true if the date is in the past.
-	* @method isPast()
-	* @returns Boolean
-	* @example
-	*   Date.create('last week').isPast() -> true
-	*   Date.create('next week').isPast() -> false
-	**/
-	isPast(): boolean;
-
-	/**
-	* Returns true if the date is this week/month/year.
-	* @method isThis[Unit]()
-	* @returns Boolean
-	* @set
-	*   isThisWeek
-	*   isThisMonth
-	*   isThisYear
-	* @example
-	*   Date.create('tomorrow').isThisWeek()  -> true or false?
-	*   Date.create('tomorrow').isThisMonth() -> probably...
-	*   Date.create('tomorrow').isThisYear()  -> signs point to yes...
-	**/
-	isThisWeek(): boolean;
-	isThisMonth(): boolean;
-	isThisYear(): boolean;
-
-	/**
-	* Returns true if the date has no timezone offset.
-	* @method isUTC()
-	* @returns Boolean
-	* @extra This will also return true for a date that has had %toUTC% called on it. This is intended to help approximate shifting timezones which is not possible in client-side Javascript. Note that the native method %getTimezoneOffset% will always report the same thing, even if %isUTC% becomes true.
-	* @example
-	*   new Date().isUTC()         -> true or false?
-	*   new Date().toUTC().isUTC() -> true
-	**/
-	isUTC(): boolean;
-
-	/**
-	* Returns true if the date is valid.
-	* @method isValid()
-	* @returns Boolean
-	* @example
-	*   new Date().isValid()         -> true
-	*   new Date('flexor').isValid() -> false
-	**/
-	isValid(): boolean;
-
-	/**
-	* @method iso()
-	* @method toISOString()
-	* @returns String
-	* Formats the string to ISO8601 format.
-	* @extra This will always format as UTC time. Provided for browsers that do not
-	*        support this method.
-	* @example
-	*   Date.create().toISOString() -> ex. 2011-07-05 12:24:55.528Z
-	**/
-	iso(): string;
-	//toISOString(): string;
-
-	/**
-	* Returns a relative date string offset to the current time.
-	* @method relative([fn], [locale] = currentLocale)
-	* @returns String
-	* @extra [fn] can be passed to provide for more granular control over the
-	*        resulting string. [fn] is passed 4 arguments: the adjusted value,
-	*        unit, offset in milliseconds, and a localization object. As an
-	*        alternate syntax, [locale] can also be passed as the first (and only)
-	*        parameter. For more, see @date_format.
-	* @example
-	*   Date.create('90 seconds ago').relative() -> 1 minute ago
-	*   Date.create('January').relative()        -> ex. 5 months ago
-	*   Date.create('January').relative('ja')    -> 3???
-	*   Date.create('120 minutes ago').relative(function(val,unit,ms,loc) {
-	*     // value = 2, unit = 3, ms = -7200, loc = [current locale object]
-	*   });                                      -> ex. 5 months ago
-	**/
-	relative(locale: string): string;
-	relative(fn?: (value: number, unit: string, ms: number, loc: Locale) => string, locale?: string): string;
-
-	/**
-	* Resets the unit passed and all smaller units. Default is "hours",
-	*        effectively resetting the time.
-	* @method reset([unit] = 'hours')
-	* @returns Date
-	* @example
-	*   Date.create().reset('day')   -> Beginning of today
-	*   Date.create().reset('month') -> 1st of the month
-	**/
-	reset(unit?: string): Date;
-
-	/**
-	* Sets the date back.
-	* @method rewind(<set>, [reset] = false)
-	* @returns Date
-	* @extra This method can accept multiple formats including a single number as a
-	*        timestamp, an object, or enumerated parameters (as with the Date
-	*        constructor). If [reset] is %true%, any units more specific than
-	*        those passed will be reset. For more see @date_format.
-	* @example
-	*   new Date().rewind({ year: 2 }) -> 2 years in the past
-	*   new Date().rewind(0, 2, 3)     -> 2 months 3 days in the past
-	*   new Date().rewind(86400000)    -> 1 day in the past
-	**/
-	rewind(ms: number, reset?: boolean): Date;
-	rewind(year: number, month: number, day: number, reset?: boolean): Date;
-	rewind(d: DateFields, reset?: boolean): Date;
-
-	/**
-	* Sets the date object.
-	* @method set(<set>, [reset] = false)
-	* @returns Date
-	* @extra This method can accept multiple formats including a single number as a
-	*        timestamp, an object, or enumerated parameters (as with the Date
-	*        constructor). If [reset] is %true%, any units more specific than those
-	*        passed will be reset.
-	* @example
-	*   new Date().set({ year: 2011, month: 11, day: 31 }) -> December 31, 2011
-	*   new Date().set(2011, 11, 31)                       -> December 31, 2011
-	*   new Date().set(86400000)                           -> 1 day after Jan 1, 1970
-	*   new Date().set({ year: 2004, month: 6 }, true)     -> June 1, 2004, 00:00:00.000
-	**/
-	set(ms: number): Date;
-	set(year: number, month: number, day: number): Date;
-	set(d: DateFields, reset?: boolean): Date;
-
-	/**
-	* Sets the week (of the year).
-	* @example
-	*   d = new Date(); d.setWeek(15); d; -> 15th week of the year
-	**/
-	setISOWeek(week: number): void;
-
-	/**
-	* Sets the weekday of the date.
-	* @method setWeekday()
-	* @returns Nothing
-	* @example
-	*   d = new Date(); d.setWeekday(1); d; -> Monday of this week
-	*   d = new Date(); d.setWeekday(6); d; -> Saturday of this week
-	**/
-	setWeekday(day: number): void;
-
-	/**
-	* Returns a JSON representation of the date.
-	* @method toJSON()
-	* @returns String
-	* @extra This is effectively an alias for %toISOString%. Will always return
-	*        the date in UTC time. Provided for browsers that do not support this
-	*        method.
-	* @example
-	*   Date.create().toJSON() -> ex. 2011-07-05 12:24:55.528Z
-	**/
-	toJSON(): string;
-
-	/**
-	* Returns the time ago in the appropriate unit.
-	* @method [units]Ago()
-	* @returns Number
-	* @set
-	*   millisecondsAgo
-	*   secondsAgo
-	*   minutesAgo
-	*   hoursAgo
-	*   daysAgo
-	*   weeksAgo
-	*   monthsAgo
-	*   yearsAgo
-	* @example
-	*   Date.create('last year').millisecondsAgo() -> 3,600,000
-	*   Date.create('last year').daysAgo()         -> 7
-	*   Date.create('last year').yearsAgo()        -> 15
-	**/
-	millisecondsAgo(): number;
-	secondsAgo(): number;
-	minutesAgo(): number;
-	hoursAgo(): number;
-	daysAgo(): number;
-	weeksAgo(): number;
-	monthsAgo(): number;
-	yearsAgo(): number;
-
-	/**
-	* Returns the time from now in the appropriate unit.
-	* @method [units]FromNow()
-	* @returns Number
-	* @set
-	*   millisecondsFromNow
-	*   secondsFromNow
-	*   minutesFromNow
-	*   hoursFromNow
-	*   daysFromNow
-	*   weeksFromNow
-	*   monthsFromNow
-	*   yearsFromNow
-	* @example
-	*   Date.create('next year').millisecondsFromNow() -> 3,600,000
-	*   Date.create('next year').daysFromNow()         -> 7
-	*   Date.create('next year').yearsFromNow()        -> 15
-	**/
-	millisecondsFromNow(): number;
-	secondsFromNow(): number;
-	minutesFromNow(): number;
-	hoursFromNow(): number;
-	daysFromNow(): number;
-	weeksFromNow(): number;
-	monthsFromNow(): number;
-	yearsFromNow(): number;
-
-	/**
-	* Returns the time since [d] in the appropriate unit.
-	* @method [units]Since([d], [locale] = currentLocale)
-	* @returns Number
-	* @extra [d] will accept a date object, timestamp, or text format. If not
-	*        specified, [d] is assumed to be now. [locale] can be passed to specify
-	*        the locale that the date is in. %[unit]Ago% is provided as an alias to
-	*        make this more readable when [d] is assumed to be the current date.
-	*        For more see @date_format.
-	* @set
-	*   millisecondsSince
-	*   secondsSince
-	*   minutesSince
-	*   hoursSince
-	*   daysSince
-	*   weeksSince
-	*   monthsSince
-	*   yearsSince
-	* @example
-	*   Date.create().millisecondsSince('1 hour ago') -> 3,600,000
-	*   Date.create().daysSince('1 week ago')         -> 7
-	*   Date.create().yearsSince('15 years ago')      -> 15
-	*   Date.create('15 years ago').yearsAgo()        -> 15
-	**/
-	millisecondsSince(date?: Date, locale?: string): number;
-	millisecondsSince(date: string, locale?: string): number;
-	secondsSince(date?: Date, locale?: string): number;
-	secondsSince(date: string, locale?: string): number;
-	minutesSince(date?: Date, locale?: string): number;
-	minutesSince(date: string, locale?: string): number;
-	hoursSince(date?: Date, locale?: string): number;
-	hoursSince(date: string, locale?: string): number;
-	daysSince(date?: Date, locale?: string): number;
-	daysSince(date: string, locale?: string): number;
-	weeksSince(date?: Date, locale?: string): number;
-	weeksSince(date: string, locale?: string): number;
-	monthsSince(date?: Date, locale?: string): number;
-	monthsSince(date: string, locale?: string): number;
-	yearsSince(date?: Date, locale?: string): number;
-	yearsSince(date: string, locale?: string): number;
-
-	/**
-	* Returns the time until [d] in the appropriate unit.
-	* @method [units]Until([d], [locale] = currentLocale)
-	* @returns Number
-	* @extra [d] will accept a date object, timestamp, or text format. If not
-	*        specified, [d] is assumed to be now. [locale] can be passed to specify
-	*        the locale that the date is in. %[unit]FromNow% is provided as an
-	*        alias to make this more readable when [d] is assumed to be the current
-	*        date. For more see @date_format.
-	* @set
-	*   millisecondsUntil
-	*   secondsUntil
-	*   minutesUntil
-	*   hoursUntil
-	*   daysUntil
-	*   weeksUntil
-	*   monthsUntil
-	*   yearsUntil
-	* @example
-	*   Date.create().millisecondsUntil('1 hour from now') -> 3,600,000
-	*   Date.create().daysUntil('1 week from now')         -> 7
-	*   Date.create().yearsUntil('15 years from now')      -> 15
-	*   Date.create('15 years from now').yearsFromNow()    -> 15
-	**/
-	millisecondsUntil(date?: Date, locale?: string): number;
-	millisecondsUntil(date: string, locale?: string): number;
-	secondsUntil(date?: Date, locale?: string): number;
-	secondsUntil(date: string, locale?: string): number;
-	minutesUntil(date?: Date, locale?: string): number;
-	minutesUntil(date: string, locale?: string): number;
-	hoursUntil(date?: Date, locale?: string): number;
-	hoursUntil(date: string, locale?: string): number;
-	daysUntil(date?: Date, locale?: string): number;
-	daysUntil(date: string, locale?: string): number;
-	weeksUntil(date?: Date, locale?: string): number;
-	weeksUntil(date: string, locale?: string): number;
-	monthsUntil(date?: Date, locale?: string): number;
-	monthsUntil(date: string, locale?: string): number;
-	yearsUntil(date?: Date, locale?: string): number;
-	yearsUntil(date: string, locale?: string): number;
-
-	/**
-	* Sets the internal utc flag for the date. When on, UTC-based methods
-	*        will be called internally.
-	* @method utc([on] = true)
-	* @returns Date
-	* @extra For more see @date_format.
-	* @example
-	*   new Date().utc(true)
-	*   new Date().utc(false)
-	**/
-	utc(on?: boolean): Date;
-}
-
-/**
-* @package DateRange
-* @dependency date
-* @description Date Ranges define a range of time. They can enumerate over specific points
-*              within that range, and be manipulated and compared.
-**/
-interface DateRange {
-	start: Date;
-	end: Date;
-
-	/**
-	* Clamps <d> to be within the range if it falls outside.
-	* @param d Date to clamp
-	* @returns <d> or closest range limit
-	* @example
-	*   Date.range('2001', '2002').clamp(Date.create('2000')) -> Mon Jan 01 2001 00:00:00
-	*   Date.range('2001', '2002').clamp(Date.create('2002')) -> Mon Jan 01 2002 00:00:00
-	**/
-	clamp(d: Date): Date;
-
-	/**
-	* Returns true if <d> is contained inside the DateRange.
-	*        <d> may be a date or another DateRange.
-	* @param d Date to check if it is contained within this DateRange.
-	* @returns True if <d> is contained within the DateRange, false otherwise.
-	* @example
-	*   Date.range('2003', '2005').contains(Date.create('2004')) -> true
-	**/
-	contains(d: Date): boolean;
-
-	/**
-	* @see contains
-	**/
-	contains(d: DateRange): boolean;
-
-	/**
-	* Iterates through the DateRange for every <increment>,
-	*        calling [fn] if it is passed. Returns an array of each increment visited.
-	* @method every(<increment>, [fn])
-	* @param ms Time span to increment by.
-	* @param fn Callback for each incremented date.
-	* @returns An array of each incremented date visited.
-	* @extra When <increment> is a number, increments will be to the exact millisecond.
-	*        <increment> can also be a string in the format %{number} {unit}s%, in which
-	*        case it will increment in the unit specified. Note that a discrepancy exists
-	*        in the case of months, as %(2).months()% is an approximation. Stepping
-	*        through the actual months by passing %"2 months"% is usually preferable in
-	*        this case.
-	* @example
-	*   Date.range('2003-01', '2003-03').every("2 months") -> [...]
-	**/
-	every(ms: number, fn?: (d: Date) => void ): Date[];
-
-	/**
-	* @see every
-	* @param increment Time span to increment by.
-	**/
-	every(increment: string, fn?: (d: Date) => void ): Date[];
-
-	/**
-	* Returns a new DateRange with the latest starting point as its start, and the
-	*        earliest ending point as its end. If the two ranges do not intersect this will
-	*        effectively produce an invalid range.
-	* @param range DateRange to intersect with.
-	* @returns DateRange
-	* @example
-	*   Date.range('2003-01', '2005-01').intersect(Date.range('2004-01', '2006-01')) -> Jan 1, 2004..Jan 1, 2005
-	**/
-	intersect(range: DateRange): DateRange;
-
-	/**
-	* Returns true if the DateRange is valid, false otherwise.
-	* @returns True if the date range is valid, false otherwise.
-	* @example
-	*   Date.range('2003', '2005').isValid() -> true
-	*   Date.range('2005', '2003').isValid() -> false
-	**/
-	isValid(): boolean;
-
-	/**
-	* Return the span of the DateRange in milliseconds. The span includes both the
-	* start and the end.
-	* @returns Duration of the DateRange in milliseconds.
-	* @example
-	*   Date.range('2003', '2005').span() -> 63158400001 # (731 day + 1 mcsec)
-	**/
-	span(): number;
-
-	/**
-	* Returns a string representation of the DateRange.
-	* @returns String representation of the DateRange.
-	* @example
-	*   Date.range('2003', '2005').toString() -> January 1, 2003..January 1, 2005
-	**/
-	toString(): string;
-
-	/**
-	* Returns a new DateRange with the earliest starting point as its start,
-	*        and the latest ending point as its end. If the two ranges do not intersect
-	*        this will effectively remove the "gap" between them.
-	* @param range DateRange to create a union with.
-	* @returns DateRange
-	* @example
-	*   Date.range('2003=01', '2005-01').union(Date.range('2004-01', '2006-01')) -> Jan 1, 2003..Jan 1, 2006
-	**/
-	union(range: DateRange): DateRange;
-}
diff --git a/sugar/tsconfig.json b/sugar/tsconfig.json
deleted file mode 100644
index 79b9eb6b27..0000000000
--- a/sugar/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es6",
-        "noImplicitAny": true,
-        "strictNullChecks": false,
-        "baseUrl": "../",
-        "typeRoots": [
-            "../"
-        ],
-        "types": [],
-        "noEmit": true,
-        "forceConsistentCasingInFileNames": true
-    },
-    "files": [
-        "index.d.ts"
-    ]
-}
\ No newline at end of file