sugar-rails 1.2.5.1 → 1.3.0

data/vendor/assets/javascripts/precompiled/development/language.js

@@ -0,0 +1,383 @@
+
+  /***
+   *
+   * @package Language
+   * @dependency string
+   * @description Normalizing accented characters, character width conversion, Hiragana and Katakana conversions.
+   *
+   ***/
+
+  /***
+   * String module
+   *
+   ***/
+
+
+
+  var NormalizeMap,
+      NormalizeReg = '',
+      NormalizeSource;
+
+
+  /***
+   * @method has[Script]()
+   * @returns Boolean
+   * @short Returns true if the string contains any characters in that script.
+   *
+   * @set
+   *   hasArabic
+   *   hasCyrillic
+   *   hasGreek
+   *   hasHangul
+   *   hasHan
+   *   hasKanji
+   *   hasHebrew
+   *   hasHiragana
+   *   hasKana
+   *   hasKatakana
+   *   hasLatin
+   *   hasThai
+   *   hasDevanagari
+   *
+   * @example
+   *
+   *   'أتكلم'.hasArabic()          -> true
+   *   'визит'.hasCyrillic()        -> true
+   *   '잘 먹겠습니다!'.hasHangul() -> true
+   *   'ミックスです'.hasKatakana() -> true
+   *   "l'année".hasLatin()         -> true
+   *
+   ***
+   * @method is[Script]()
+   * @returns Boolean
+   * @short Returns true if the string contains only characters in that script. Whitespace is ignored.
+   *
+   * @set
+   *   isArabic
+   *   isCyrillic
+   *   isGreek
+   *   isHangul
+   *   isHan
+   *   isKanji
+   *   isHebrew
+   *   isHiragana
+   *   isKana
+   *   isKatakana
+   *   isKatakana
+   *   isThai
+   *   isDevanagari
+   *
+   * @example
+   *
+   *   'أتكلم'.isArabic()          -> true
+   *   'визит'.isCyrillic()        -> true
+   *   '잘 먹겠습니다!'.isHangul() -> true
+   *   'ミックスです'.isKatakana() -> false
+   *   "l'année".isLatin()         -> true
+   *
+   ***/
+  var unicodeScripts = [
+    { names: ['Arabic'],      source: '\u0600-\u06FF' },
+    { names: ['Cyrillic'],    source: '\u0400-\u04FF' },
+    { names: ['Devanagari'],  source: '\u0900-\u097F' },
+    { names: ['Greek'],       source: '\u0370-\u03FF' },
+    { names: ['Hangul'],      source: '\uAC00-\uD7AF\u1100-\u11FF' },
+    { names: ['Han','Kanji'], source: '\u4E00-\u9FFF\uF900-\uFAFF' },
+    { names: ['Hebrew'],      source: '\u0590-\u05FF' },
+    { names: ['Hiragana'],    source: '\u3040-\u309F\u30FB-\u30FC' },
+    { names: ['Kana'],        source: '\u3040-\u30FF\uFF61-\uFF9F' },
+    { names: ['Katakana'],    source: '\u30A0-\u30FF\uFF61-\uFF9F' },
+    { names: ['Latin'],       source: '\u0001-\u007F\u0080-\u00FF\u0100-\u017F\u0180-\u024F' },
+    { names: ['Thai'],        source: '\u0E00-\u0E7F' }
+  ];
+
+  function buildUnicodeScripts() {
+    unicodeScripts.forEach(function(s) {
+      var is = regexp('^['+s.source+'\\s]+$');
+      var has = regexp('['+s.source+']');
+      s.names.forEach(function(name) {
+        defineProperty(string.prototype, 'is' + name, function() { return is.test(this.trim()); });
+        defineProperty(string.prototype, 'has' + name, function() { return has.test(this); });
+      });
+    });
+  }
+
+  // Support for converting character widths and katakana to hiragana.
+
+  var widthConversionRanges = [
+    { type: 'a', shift: 65248, start: 65,  end: 90  },
+    { type: 'a', shift: 65248, start: 97,  end: 122 },
+    { type: 'n', shift: 65248, start: 48,  end: 57  },
+    { type: 'p', shift: 65248, start: 33,  end: 47  },
+    { type: 'p', shift: 65248, start: 58,  end: 64  },
+    { type: 'p', shift: 65248, start: 91,  end: 96  },
+    { type: 'p', shift: 65248, start: 123, end: 126 }
+  ];
+
+  var WidthConversionTable;
+  var allHankaku   = /[\u0020-\u00A5]|[\uFF61-\uFF9F][ﾞﾟ]?/g;
+  var allZenkaku   = /[\u3000-\u301C]|[\u301A-\u30FC]|[\uFF01-\uFF60]|[\uFFE0-\uFFE6]/g;
+  var hankakuPunctuation  = '｡､｢｣¥¢£';
+  var zenkakuPunctuation  = '。、「」￥￠￡';
+  var voicedKatakana      = /[カキクケコサシスセソタチツテトハヒフヘホ]/;
+  var semiVoicedKatakana  = /[ハヒフヘホヲ]/;
+  var hankakuKatakana     = 'ｱｲｳｴｵｧｨｩｪｫｶｷｸｹｺｻｼｽｾｿﾀﾁﾂｯﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔｬﾕｭﾖｮﾗﾘﾙﾚﾛﾜｦﾝｰ･';
+  var zenkakuKatakana     = 'アイウエオァィゥェォカキクケコサシスセソタチツッテトナニヌネノハヒフヘホマミムメモヤャユュヨョラリルレロワヲンー・';
+
+  function convertCharacterWidth(str, args, reg, type) {
+    if(!WidthConversionTable) {
+      buildWidthConversionTables();
+    }
+    var mode = multiArgs(args).join(''), table = WidthConversionTable[type];
+    mode = mode.replace(/all/, '').replace(/(\w)lphabet|umbers?|atakana|paces?|unctuation/g, '$1');
+    return str.replace(reg, function(c) {
+      if(table[c] && (!mode || mode.has(table[c].type))) {
+        return table[c].to;
+      } else {
+        return c;
+      }
+    });
+  }
+
+  function buildWidthConversionTables() {
+    var hankaku;
+    WidthConversionTable = {
+      'zenkaku': {},
+      'hankaku': {}
+    };
+    widthConversionRanges.forEach(function(r) {
+      getRange(r.start, r.end, function(n) {
+        setWidthConversion(r.type, chr(n), chr(n + r.shift));
+      });
+    });
+    zenkakuKatakana.each(function(c, i) {
+      hankaku = hankakuKatakana.charAt(i);
+      setWidthConversion('k', hankaku, c);
+      if(c.match(voicedKatakana)) {
+        setWidthConversion('k', hankaku + 'ﾞ', c.shift(1));
+      }
+      if(c.match(semiVoicedKatakana)) {
+        setWidthConversion('k', hankaku + 'ﾟ', c.shift(2));
+      }
+    });
+    zenkakuPunctuation.each(function(c, i) {
+      setWidthConversion('p', hankakuPunctuation.charAt(i), c);
+    });
+    setWidthConversion('k', 'ｳﾞ', 'ヴ');
+    setWidthConversion('k', 'ｦﾞ', 'ヺ');
+    setWidthConversion('s', ' ', '　');
+  }
+
+  function setWidthConversion(type, half, full) {
+    WidthConversionTable['zenkaku'][half] = { type: type, to: full };
+    WidthConversionTable['hankaku'][full] = { type: type, to: half };
+  }
+
+
+
+
+  function buildNormalizeMap() {
+    NormalizeMap = {};
+    iterateOverObject(NormalizeSource, function(normalized, str) {
+      str.split('').forEach(function(character) {
+        NormalizeMap[character] = normalized;
+      });
+      NormalizeReg += str;
+    });
+    NormalizeReg = regexp('[' + NormalizeReg + ']', 'g');
+  }
+
+  NormalizeSource = {
+    'A':  'AⒶＡÀÁÂẦẤẪẨÃĀĂẰẮẴẲȦǠÄǞẢÅǺǍȀȂẠẬẶḀĄȺⱯ',
+    'B':  'BⒷＢḂḄḆɃƂƁ',
+    'C':  'CⒸＣĆĈĊČÇḈƇȻꜾ',
+    'D':  'DⒹＤḊĎḌḐḒḎĐƋƊƉꝹ',
+    'E':  'EⒺＥÈÉÊỀẾỄỂẼĒḔḖĔĖËẺĚȄȆẸỆȨḜĘḘḚƐƎ',
+    'F':  'FⒻＦḞƑꝻ',
+    'G':  'GⒼＧǴĜḠĞĠǦĢǤƓꞠꝽꝾ',
+    'H':  'HⒽＨĤḢḦȞḤḨḪĦⱧⱵꞍ',
+    'I':  'IⒾＩÌÍÎĨĪĬİÏḮỈǏȈȊỊĮḬƗ',
+    'J':  'JⒿＪĴɈ',
+    'K':  'KⓀＫḰǨḲĶḴƘⱩꝀꝂꝄꞢ',
+    'L':  'LⓁＬĿĹĽḶḸĻḼḺŁȽⱢⱠꝈꝆꞀ',
+    'M':  'MⓂＭḾṀṂⱮƜ',
+    'N':  'NⓃＮǸŃÑṄŇṆŅṊṈȠƝꞐꞤ',
+    'O':  'OⓄＯÒÓÔỒỐỖỔÕṌȬṎŌṐṒŎȮȰÖȪỎŐǑȌȎƠỜỚỠỞỢỌỘǪǬØǾƆƟꝊꝌ',
+    'P':  'PⓅＰṔṖƤⱣꝐꝒꝔ',
+    'Q':  'QⓆＱꝖꝘɊ',
+    'R':  'RⓇＲŔṘŘȐȒṚṜŖṞɌⱤꝚꞦꞂ',
+    'S':  'SⓈＳẞŚṤŜṠŠṦṢṨȘŞⱾꞨꞄ',
+    'T':  'TⓉＴṪŤṬȚŢṰṮŦƬƮȾꞆ',
+    'U':  'UⓊＵÙÚÛŨṸŪṺŬÜǛǗǕǙỦŮŰǓȔȖƯỪỨỮỬỰỤṲŲṶṴɄ',
+    'V':  'VⓋＶṼṾƲꝞɅ',
+    'W':  'WⓌＷẀẂŴẆẄẈⱲ',
+    'X':  'XⓍＸẊẌ',
+    'Y':  'YⓎＹỲÝŶỸȲẎŸỶỴƳɎỾ',
+    'Z':  'ZⓏＺŹẐŻŽẒẔƵȤⱿⱫꝢ',
+    'a':  'aⓐａẚàáâầấẫẩãāăằắẵẳȧǡäǟảåǻǎȁȃạậặḁąⱥɐ',
+    'b':  'bⓑｂḃḅḇƀƃɓ',
+    'c':  'cⓒｃćĉċčçḉƈȼꜿↄ',
+    'd':  'dⓓｄḋďḍḑḓḏđƌɖɗꝺ',
+    'e':  'eⓔｅèéêềếễểẽēḕḗĕėëẻěȅȇẹệȩḝęḙḛɇɛǝ',
+    'f':  'fⓕｆḟƒꝼ',
+    'g':  'gⓖｇǵĝḡğġǧģǥɠꞡᵹꝿ',
+    'h':  'hⓗｈĥḣḧȟḥḩḫẖħⱨⱶɥ',
+    'i':  'iⓘｉìíîĩīĭïḯỉǐȉȋịįḭɨı',
+    'j':  'jⓙｊĵǰɉ',
+    'k':  'kⓚｋḱǩḳķḵƙⱪꝁꝃꝅꞣ',
+    'l':  'lⓛｌŀĺľḷḹļḽḻſłƚɫⱡꝉꞁꝇ',
+    'm':  'mⓜｍḿṁṃɱɯ',
+    'n':  'nⓝｎǹńñṅňṇņṋṉƞɲʼnꞑꞥ',
+    'o':  'oⓞｏòóôồốỗổõṍȭṏōṑṓŏȯȱöȫỏőǒȍȏơờớỡởợọộǫǭøǿɔꝋꝍɵ',
+    'p':  'pⓟｐṕṗƥᵽꝑꝓꝕ',
+    'q':  'qⓠｑɋꝗꝙ',
+    'r':  'rⓡｒŕṙřȑȓṛṝŗṟɍɽꝛꞧꞃ',
+    's':  'sⓢｓśṥŝṡšṧṣṩșşȿꞩꞅẛ',
+    't':  'tⓣｔṫẗťṭțţṱṯŧƭʈⱦꞇ',
+    'u':  'uⓤｕùúûũṹūṻŭüǜǘǖǚủůűǔȕȗưừứữửựụṳųṷṵʉ',
+    'v':  'vⓥｖṽṿʋꝟʌ',
+    'w':  'wⓦｗẁẃŵẇẅẘẉⱳ',
+    'x':  'xⓧｘẋẍ',
+    'y':  'yⓨｙỳýŷỹȳẏÿỷẙỵƴɏỿ',
+    'z':  'zⓩｚźẑżžẓẕƶȥɀⱬꝣ',
+    'AA': 'Ꜳ',
+    'AE': 'ÆǼǢ',
+    'AO': 'Ꜵ',
+    'AU': 'Ꜷ',
+    'AV': 'ꜸꜺ',
+    'AY': 'Ꜽ',
+    'DZ': 'DZDŽ',
+    'Dz': 'DzDž',
+    'LJ': 'LJ',
+    'Lj': 'Lj',
+    'NJ': 'NJ',
+    'Nj': 'Nj',
+    'OI': 'Ƣ',
+    'OO': 'Ꝏ',
+    'OU': 'Ȣ',
+    'TZ': 'Ꜩ',
+    'VY': 'Ꝡ',
+    'aa': 'ꜳ',
+    'ae': 'æǽǣ',
+    'ao': 'ꜵ',
+    'au': 'ꜷ',
+    'av': 'ꜹꜻ',
+    'ay': 'ꜽ',
+    'dz': 'dzdž',
+    'hv': 'ƕ',
+    'lj': 'lj',
+    'nj': 'nj',
+    'oi': 'ƣ',
+    'ou': 'ȣ',
+    'oo': 'ꝏ',
+    'ss': 'ß',
+    'tz': 'ꜩ',
+    'vy': 'ꝡ'
+  };
+
+  extend(string, true, false, {
+    /***
+     * @method normalize()
+     * @returns String
+     * @short Returns the string with accented and non-standard Latin-based characters converted into ASCII approximate equivalents.
+     * @example
+     *
+     *   'á'.normalize()                  -> 'a'
+     *   'Ménage à trois'.normalize()     -> 'Menage a trois'
+     *   'Volkswagen'.normalize()         -> 'Volkswagen'
+     *   'ＦＵＬＬＷＩＤＴＨ'.normalize() -> 'FULLWIDTH'
+     *
+     ***/
+    'normalize': function() {
+      if(!NormalizeMap) {
+        buildNormalizeMap();
+      }
+      return this.replace(NormalizeReg, function(character) {
+        return NormalizeMap[character];
+      });
+    },
+
+    /***
+     * @method hankaku([mode] = 'all')
+     * @returns String
+     * @short Converts full-width characters (zenkaku) to half-width (hankaku).
+     * @extra [mode] accepts any combination of "a" (alphabet), "n" (numbers), "k" (katakana), "s" (spaces), "p" (punctuation), or "all".
+     * @example
+     *
+     *   'タロウ　ＹＡＭＡＤＡです！'.hankaku()                      -> 'ﾀﾛｳ YAMADAです!'
+     *   'タロウ　ＹＡＭＡＤＡです！'.hankaku('a')                   -> 'タロウ　YAMADAです！'
+     *   'タロウ　ＹＡＭＡＤＡです！'.hankaku('alphabet')            -> 'タロウ　YAMADAです！'
+     *   'タロウです！　２５歳です！'.hankaku('katakana', 'numbers') -> 'ﾀﾛｳです！　25歳です！'
+     *   'タロウです！　２５歳です！'.hankaku('k', 'n')              -> 'ﾀﾛｳです！　25歳です！'
+     *   'タロウです！　２５歳です！'.hankaku('kn')                  -> 'ﾀﾛｳです！　25歳です！'
+     *   'タロウです！　２５歳です！'.hankaku('sp')                  -> 'タロウです! ２５歳です!'
+     *
+     ***/
+    'hankaku': function() {
+      return convertCharacterWidth(this, arguments, allZenkaku, 'hankaku');
+    },
+
+    /***
+     * @method zenkaku([mode] = 'all')
+     * @returns String
+     * @short Converts half-width characters (hankaku) to full-width (zenkaku).
+     * @extra [mode] accepts any combination of "a" (alphabet), "n" (numbers), "k" (katakana), "s" (spaces), "p" (punctuation), or "all".
+     * @example
+     *
+     *   'ﾀﾛｳ YAMADAです!'.zenkaku()                         -> 'タロウ　ＹＡＭＡＤＡです！'
+     *   'ﾀﾛｳ YAMADAです!'.zenkaku('a')                      -> 'ﾀﾛｳ ＹＡＭＡＤＡです!'
+     *   'ﾀﾛｳ YAMADAです!'.zenkaku('alphabet')               -> 'ﾀﾛｳ ＹＡＭＡＤＡです!'
+     *   'ﾀﾛｳです! 25歳です!'.zenkaku('katakana', 'numbers') -> 'タロウです! ２５歳です!'
+     *   'ﾀﾛｳです! 25歳です!'.zenkaku('k', 'n')              -> 'タロウです! ２５歳です!'
+     *   'ﾀﾛｳです! 25歳です!'.zenkaku('kn')                  -> 'タロウです! ２５歳です!'
+     *   'ﾀﾛｳです! 25歳です!'.zenkaku('sp')                  -> 'ﾀﾛｳです！　25歳です！'
+     *
+     ***/
+    'zenkaku': function() {
+      return convertCharacterWidth(this, arguments, allHankaku, 'zenkaku');
+    },
+
+    /***
+     * @method hiragana([all] = true)
+     * @returns String
+     * @short Converts katakana into hiragana.
+     * @extra If [all] is false, only full-width katakana will be converted.
+     * @example
+     *
+     *   'カタカナ'.hiragana()   -> 'かたかな'
+     *   'コンニチハ'.hiragana() -> 'こんにちは'
+     *   'ｶﾀｶﾅ'.hiragana()       -> 'かたかな'
+     *   'ｶﾀｶﾅ'.hiragana(false)  -> 'ｶﾀｶﾅ'
+     *
+     ***/
+    'hiragana': function(all) {
+      var str = this;
+      if(all !== false) {
+        str = str.zenkaku('k');
+      }
+      return str.replace(/[\u30A1-\u30F6]/g, function(c) {
+        return c.shift(-96);
+      });
+    },
+
+    /***
+     * @method katakana()
+     * @returns String
+     * @short Converts hiragana into katakana.
+     * @example
+     *
+     *   'かたかな'.katakana()   -> 'カタカナ'
+     *   'こんにちは'.katakana() -> 'コンニチハ'
+     *
+     ***/
+    'katakana': function() {
+      return this.replace(/[\u3041-\u3096]/g, function(c) {
+        return c.shift(96);
+      });
+    }
+
+
+  });
+
+  buildUnicodeScripts();
+

data/vendor/assets/javascripts/precompiled/development/number.js

@@ -0,0 +1,422 @@
+
+  /***
+   * @package Number
+   * @dependency core
+   * @description Number formatting, rounding (with precision), and ranges. Aliases to Math methods.
+   *
+   ***/
+
+
+  function abbreviateNumber(num, roundTo, str, mid, limit, bytes) {
+    var fixed        = num.toFixed(20),
+        decimalPlace = fixed.search(/\./),
+        numeralPlace = fixed.search(/[1-9]/),
+        significant  = decimalPlace - numeralPlace,
+        unit, i, divisor;
+    if(significant > 0) {
+      significant -= 1;
+    }
+    i = math.max(math.min((significant / 3).floor(), limit === false ? str.length : limit), -mid);
+    unit = str.charAt(i + mid - 1);
+    if(significant < -9) {
+      i = -3;
+      roundTo = significant.abs() - 9;
+      unit = str.slice(0,1);
+    }
+    divisor = bytes ? (2).pow(10 * i) : (10).pow(i * 3);
+    return (num / divisor).round(roundTo || 0).format() + unit.trim();
+  }
+
+
+  extend(number, false, false, {
+
+    /***
+     * @method Number.random([n1], [n2])
+     * @returns Number
+     * @short Returns a random integer 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': function(n1, n2) {
+      var min, max;
+      if(arguments.length == 1) n2 = n1, n1 = 0;
+      min = math.min(n1 || 0, isUndefined(n2) ? 1 : n2);
+      max = math.max(n1 || 0, isUndefined(n2) ? 1 : n2);
+      return round((math.random() * (max - min)) + min);
+    }
+
+  });
+
+  extend(number, true, false, {
+
+    /***
+     * @method log(<base> = Math.E)
+     * @returns Number
+     * @short Returns the logarithm of the number with base <base>, or natural logarithm of the number if <base> is undefined.
+     * @example
+     *
+     *   (64).log(2) -> 6
+     *   (9).log(3)  -> 2
+     *   (5).log()   -> 1.6094379124341003
+     *
+     ***/
+
+    'log': function(base) {
+       return math.log(this) / (base ? math.log(base) : 1);
+     },
+
+    /***
+     * @method abbr([precision] = 0)
+     * @returns String
+     * @short Returns an abbreviated form of the number.
+     * @extra [precision] will round to the given precision.
+     * @example
+     *
+     *   (1000).abbr()    -> "1k"
+     *   (1000000).abbr() -> "1m"
+     *   (1280).abbr(1)   -> "1.3k"
+     *
+     ***/
+    'abbr': function(precision) {
+      return abbreviateNumber(this, precision, 'kmbt', 0, 4);
+    },
+
+    /***
+     * @method metric([precision] = 0, [limit] = 1)
+     * @returns String
+     * @short Returns the number as a string in metric notation.
+     * @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': function(precision, limit) {
+      return abbreviateNumber(this, precision, 'nμm kMGTPE', 4, isUndefined(limit) ? 1 : limit);
+    },
+
+    /***
+     * @method bytes([precision] = 0, [limit] = 4)
+     * @returns String
+     * @short Returns an abbreviated form of the number, considered to be "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': function(precision, limit) {
+      return abbreviateNumber(this, precision, 'kMGTPE', 0, isUndefined(limit) ? 4 : limit, true) + 'B';
+    },
+
+    /***
+     * @method isInteger()
+     * @returns Boolean
+     * @short Returns true if the number has no trailing decimal.
+     * @example
+     *
+     *   (420).isInteger() -> true
+     *   (4.5).isInteger() -> false
+     *
+     ***/
+    'isInteger': function() {
+      return this % 1 == 0;
+    },
+
+    /***
+     * @method isOdd()
+     * @returns Boolean
+     * @short Returns true if the number is odd.
+     * @example
+     *
+     *   (3).isOdd()  -> true
+     *   (18).isOdd() -> false
+     *
+     ***/
+    'isOdd': function() {
+      return !this.isMultipleOf(2);
+    },
+
+    /***
+     * @method isEven()
+     * @returns Boolean
+     * @short Returns true if the number is even.
+     * @example
+     *
+     *   (6).isEven()  -> true
+     *   (17).isEven() -> false
+     *
+     ***/
+    'isEven': function() {
+      return this.isMultipleOf(2);
+    },
+
+    /***
+     * @method isMultipleOf(<num>)
+     * @returns Boolean
+     * @short 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': function(num) {
+      return this % num === 0;
+    },
+
+
+    /***
+     * @method format([place] = 0, [thousands] = ',', [decimal] = '.')
+     * @returns String
+     * @short Formats the number to a readable 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': function(place, thousands, decimal) {
+      var str, split, method, after, r = /(\d+)(\d{3})/;
+      if(string(thousands).match(/\d/)) throw new TypeError('Thousands separator cannot contain numbers.');
+      str = isNumber(place) ? round(this, place || 0).toFixed(math.max(place, 0)) : this.toString();
+      thousands = thousands || ',';
+      decimal = decimal || '.';
+      split = str.split('.');
+      str = split[0];
+      after = split[1] || '';
+      while (str.match(r)) {
+        str = str.replace(r, '$1' + thousands + '$2');
+      }
+      if(after.length > 0) {
+        str += decimal + repeatString((place || 0) - after.length, '0') + after;
+      }
+      return str;
+    },
+
+    /***
+     * @method hex([pad] = 1)
+     * @returns String
+     * @short Converts the number to hexidecimal.
+     * @extra [pad] will pad the resulting string to that many places.
+     * @example
+     *
+     *   (255).hex()   -> 'ff';
+     *   (255).hex(4)  -> '00ff';
+     *   (23654).hex() -> '5c66';
+     *
+     ***/
+    'hex': function(pad) {
+      return this.pad(pad || 1, false, 16);
+    },
+
+    /***
+     * @method upto(<num>, [fn], [step] = 1)
+     * @returns Array
+     * @short Returns an array containing numbers from the 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': function(num, fn, step) {
+      return getRange(this, num, fn, step || 1);
+    },
+
+    /***
+     * @method downto(<num>, [fn], [step] = 1)
+     * @returns Array
+     * @short Returns an array containing numbers from the 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': function(num, fn, step) {
+      return getRange(this, num, fn, -(step || 1));
+    },
+
+    /***
+     * @method times(<fn>)
+     * @returns Number
+     * @short Calls <fn> a number of times equivalent to the number.
+     * @example
+     *
+     *   (8).times(function(i) {
+     *     // This function is called 8 times.
+     *   });
+     *
+     ***/
+    'times': function(fn) {
+      if(fn) {
+        for(var i = 0; i < this; i++) {
+          fn.call(this, i);
+        }
+      }
+      return this.toNumber();
+    },
+
+    /***
+     * @method chr()
+     * @returns String
+     * @short Returns a string at the code point of the number.
+     * @example
+     *
+     *   (65).chr() -> "A"
+     *   (75).chr() -> "K"
+     *
+     ***/
+    'chr': function() {
+      return string.fromCharCode(this);
+    },
+
+    /***
+     * @method pad(<place> = 0, [sign] = false, [base] = 10)
+     * @returns String
+     * @short Pads a number with "0" to <place>.
+     * @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': function(place, sign, base) {
+      return padNumber(this, place, sign, base);
+    },
+
+    /***
+     * @method ordinalize()
+     * @returns String
+     * @short Returns an ordinalized (English) string, i.e. "1st", "2nd", etc.
+     * @example
+     *
+     *   (1).ordinalize() -> '1st';
+     *   (2).ordinalize() -> '2nd';
+     *   (8).ordinalize() -> '8th';
+     *
+     ***/
+    'ordinalize': function() {
+      var suffix, num = this.abs(), last = parseInt(num.toString().slice(-2));
+      return this + getOrdinalizedSuffix(last);
+    },
+
+    /***
+     * @method toNumber()
+     * @returns Number
+     * @short Returns a number. This is mostly for compatibility reasons.
+     * @example
+     *
+     *   (420).toNumber() -> 420
+     *
+     ***/
+    'toNumber': function() {
+      return parseFloat(this, 10);
+    }
+
+  });
+
+  /***
+   * @method round(<precision> = 0)
+   * @returns Number
+   * @short Shortcut for %Math.round% that also allows a <precision>.
+   *
+   * @example
+   *
+   *   (3.241).round()  -> 3
+   *   (-3.841).round() -> -4
+   *   (3.241).round(2) -> 3.24
+   *   (3748).round(-2) -> 3800
+   *
+   ***
+   * @method ceil(<precision> = 0)
+   * @returns Number
+   * @short Shortcut for %Math.ceil% that also allows a <precision>.
+   *
+   * @example
+   *
+   *   (3.241).ceil()  -> 4
+   *   (-3.241).ceil() -> -3
+   *   (3.241).ceil(2) -> 3.25
+   *   (3748).ceil(-2) -> 3800
+   *
+   ***
+   * @method floor(<precision> = 0)
+   * @returns Number
+   * @short Shortcut for %Math.floor% that also allows a <precision>.
+   *
+   * @example
+   *
+   *   (3.241).floor()  -> 3
+   *   (-3.841).floor() -> -4
+   *   (3.241).floor(2) -> 3.24
+   *   (3748).floor(-2) -> 3700
+   *
+   ***
+   * @method [math]()
+   * @returns Number
+   * @short Math related functions are mapped as shortcuts to numbers and are identical. Note that %Number#log% provides some special defaults.
+   *
+   * @set
+   *   abs
+   *   sin
+   *   asin
+   *   cos
+   *   acos
+   *   tan
+   *   atan
+   *   sqrt
+   *   exp
+   *   pow
+   *
+   * @example
+   *
+   *   (3).pow(3) -> 27
+   *   (-3).abs() -> 3
+   *   (1024).sqrt() -> 32
+   *
+   ***/
+
+  function buildNumber() {
+    extendSimilar(number, true, false, 'round,floor,ceil', function(methods, name) {
+      methods[name] = function(precision) {
+        return round(this, precision, name);
+      }
+    });
+    extendSimilar(number, true, false, 'abs,pow,sin,asin,cos,acos,tan,atan,exp,pow,sqrt', function(methods, name) {
+      methods[name] = function(a, b) {
+        return math[name](this, a, b);
+      }
+    });
+  }
+
+  buildNumber();
+