zikula / core

* Underscore.string

* (c) 2010 Esa-Matti Suuronen <esa-matti aet suuronen dot org>

* Underscore.string is freely distributable under the terms of the MIT license.

* Documentation: https://github.com/epeli/underscore.string

* Some code is borrowed from MooTools and Alexandru Marasteanu.

* Version '3.3.4'

* @preserve

*/

var trim = require('./trim');

var decap = require('./decapitalize');

module.exports = function camelize(str, decapitalize) {

  str = trim(str).replace(/[-_\s]+(.)?/g, function(match, c) {

    return c ? c.toUpperCase() : '';

  });

  if (decapitalize === true) {

    return decap(str);

  } else {

    return str;

  }

};

},{"./decapitalize":10,"./trim":65}],2:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function capitalize(str, lowercaseRest) {

  str = makeString(str);

  var remainingChars = !lowercaseRest ? str.slice(1) : str.slice(1).toLowerCase();

  return str.charAt(0).toUpperCase() + remainingChars;

};

},{"./helper/makeString":20}],3:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function chars(str) {

  return makeString(str).split('');

};

},{"./helper/makeString":20}],4:[function(require,module,exports){

module.exports = function chop(str, step) {

  if (str == null) return [];

  str = String(str);

  step = ~~step;

  return step > 0 ? str.match(new RegExp('.{1,' + step + '}', 'g')) : [str];

};

},{}],5:[function(require,module,exports){

var capitalize = require('./capitalize');

var camelize = require('./camelize');

var makeString = require('./helper/makeString');

module.exports = function classify(str) {

  str = makeString(str);

  return capitalize(camelize(str.replace(/[\W_]/g, ' ')).replace(/\s/g, ''));

};

},{"./camelize":1,"./capitalize":2,"./helper/makeString":20}],6:[function(require,module,exports){

var trim = require('./trim');

module.exports = function clean(str) {

  return trim(str).replace(/\s\s+/g, ' ');

};

},{"./trim":65}],7:[function(require,module,exports){

var makeString = require('./helper/makeString');

var from  = 'ąàáäâãåæăćčĉęèéëêĝĥìíïîĵłľńňòóöőôõðøśșşšŝťțţŭùúüűûñÿýçżźž',

  to    = 'aaaaaaaaaccceeeeeghiiiijllnnoooooooossssstttuuuuuunyyczzz';

from += from.toUpperCase();

to += to.toUpperCase();

to = to.split('');

// for tokens requireing multitoken output

from += 'ß';

to.push('ss');

module.exports = function cleanDiacritics(str) {

  return makeString(str).replace(/.{1}/g, function(c){

    var index = from.indexOf(c);

    return index === -1 ? c : to[index];

  });

};

},{"./helper/makeString":20}],8:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function(str, substr) {

  str = makeString(str);

  substr = makeString(substr);

  if (str.length === 0 || substr.length === 0) return 0;

  return str.split(substr).length - 1;

};

},{"./helper/makeString":20}],9:[function(require,module,exports){

var trim = require('./trim');

module.exports = function dasherize(str) {

  return trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();

};

},{"./trim":65}],10:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function decapitalize(str) {

  str = makeString(str);

  return str.charAt(0).toLowerCase() + str.slice(1);

};

},{"./helper/makeString":20}],11:[function(require,module,exports){

var makeString = require('./helper/makeString');

function getIndent(str) {

  var matches = str.match(/^[\s\\t]*/gm);

  var indent = matches[0].length;

  for (var i = 1; i < matches.length; i++) {

    indent = Math.min(matches[i].length, indent);

  }

  return indent;

}

module.exports = function dedent(str, pattern) {

  str = makeString(str);

  var indent = getIndent(str);

  var reg;

  if (indent === 0) return str;

  if (typeof pattern === 'string') {

    reg = new RegExp('^' + pattern, 'gm');

  } else {

    reg = new RegExp('^[ \\t]{' + indent + '}', 'gm');

  }

  return str.replace(reg, '');

};

},{"./helper/makeString":20}],12:[function(require,module,exports){

var makeString = require('./helper/makeString');

var toPositive = require('./helper/toPositive');

module.exports = function endsWith(str, ends, position) {

  str = makeString(str);

  ends = '' + ends;

  if (typeof position == 'undefined') {

    position = str.length - ends.length;

  } else {

    position = Math.min(toPositive(position), str.length) - ends.length;

  }

  return position >= 0 && str.indexOf(ends, position) === position;

};

},{"./helper/makeString":20,"./helper/toPositive":22}],13:[function(require,module,exports){

var makeString = require('./helper/makeString');

var escapeChars = require('./helper/escapeChars');

var regexString = '[';

  regexString += key;

}

regexString += ']';

var regex = new RegExp( regexString, 'g');

module.exports = function escapeHTML(str) {

  return makeString(str).replace(regex, function(m) {

    return '&' + escapeChars[m] + ';';

  });

};

},{"./helper/escapeChars":17,"./helper/makeString":20}],14:[function(require,module,exports){

module.exports = function() {

  var result = {};

  for (var prop in this) {

    if (!this.hasOwnProperty(prop) || prop.match(/^(?:include|contains|reverse|join|map|wrap)$/)) continue;

    result[prop] = this[prop];

  }

  return result;

};

},{}],15:[function(require,module,exports){

var makeString = require('./makeString');

module.exports = function adjacent(str, direction) {

  str = makeString(str);

  if (str.length === 0) {

    return '';

  }

  return str.slice(0, -1) + String.fromCharCode(str.charCodeAt(str.length - 1) + direction);

};

},{"./makeString":20}],16:[function(require,module,exports){

var escapeRegExp = require('./escapeRegExp');

module.exports = function defaultToWhiteSpace(characters) {

  if (characters == null)

    return '\\s';

  else if (characters.source)

    return characters.source;

  else

    return '[' + escapeRegExp(characters) + ']';

};

},{"./escapeRegExp":18}],17:[function(require,module,exports){

/* We're explicitly defining the list of entities we want to escape.

nbsp is an HTML entity, but we don't want to escape all space characters in a string, hence its omission in this map.

*/

var escapeChars = {

  '¢' : 'cent',

  '£' : 'pound',

  '¥' : 'yen',

  '€': 'euro',

  '©' :'copy',

  '®' : 'reg',

  '<' : 'lt',

  '>' : 'gt',

  '"' : 'quot',

  '&' : 'amp',

  '\'' : '#39'

};

module.exports = escapeChars;

},{}],18:[function(require,module,exports){

var makeString = require('./makeString');

module.exports = function escapeRegExp(str) {

  return makeString(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');

};

},{"./makeString":20}],19:[function(require,module,exports){

/*

We're explicitly defining the list of entities that might see in escape HTML strings

*/

var htmlEntities = {

  nbsp: ' ',

  cent: '¢',

  pound: '£',

  yen: '¥',

  euro: '€',

  copy: '©',

  reg: '®',

  lt: '<',

  gt: '>',

  quot: '"',

  amp: '&',

  apos: '\''

};

module.exports = htmlEntities;

},{}],20:[function(require,module,exports){

/**

 * Ensure some object is a coerced to a string

 **/

module.exports = function makeString(object) {

  if (object == null) return '';

  return '' + object;

};

},{}],21:[function(require,module,exports){

module.exports = function strRepeat(str, qty){

  if (qty < 1) return '';

  var result = '';

  while (qty > 0) {

  }

  return result;

};

},{}],22:[function(require,module,exports){

module.exports = function toPositive(number) {

  return number < 0 ? 0 : (+number || 0);

};

},{}],23:[function(require,module,exports){

var capitalize = require('./capitalize');

var underscored = require('./underscored');

var trim = require('./trim');

module.exports = function humanize(str) {

  return capitalize(trim(underscored(str).replace(/_id$/, '').replace(/_/g, ' ')));

};

},{"./capitalize":2,"./trim":65,"./underscored":67}],24:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function include(str, needle) {

  if (needle === '') return true;

  return makeString(str).indexOf(needle) !== -1;

};

},{"./helper/makeString":20}],25:[function(require,module,exports){

/*

* Underscore.string

* (c) 2010 Esa-Matti Suuronen <esa-matti aet suuronen dot org>

* Underscore.string is freely distributable under the terms of the MIT license.

* Documentation: https://github.com/epeli/underscore.string

* Some code is borrowed from MooTools and Alexandru Marasteanu.

* Version '3.3.4'

* @preserve

*/

'use strict';

function s(value) {

  /* jshint validthis: true */

}

s.VERSION = '3.3.4';

s.isBlank          = require('./isBlank');

s.stripTags        = require('./stripTags');

s.capitalize       = require('./capitalize');

s.decapitalize     = require('./decapitalize');

s.chop             = require('./chop');

s.trim             = require('./trim');

s.clean            = require('./clean');

s.cleanDiacritics  = require('./cleanDiacritics');

s.count            = require('./count');

s.chars            = require('./chars');

s.swapCase         = require('./swapCase');

s.escapeHTML       = require('./escapeHTML');

s.unescapeHTML     = require('./unescapeHTML');

s.splice           = require('./splice');

s.insert           = require('./insert');

s.replaceAll       = require('./replaceAll');

s.include          = require('./include');

s.join             = require('./join');

s.lines            = require('./lines');

s.dedent           = require('./dedent');

s.reverse          = require('./reverse');

s.startsWith       = require('./startsWith');

s.endsWith         = require('./endsWith');

s.pred             = require('./pred');

s.succ             = require('./succ');

s.titleize         = require('./titleize');

s.camelize         = require('./camelize');

s.underscored      = require('./underscored');

s.dasherize        = require('./dasherize');

s.classify         = require('./classify');

s.humanize         = require('./humanize');

s.ltrim            = require('./ltrim');

s.rtrim            = require('./rtrim');

s.truncate         = require('./truncate');

s.prune            = require('./prune');

s.words            = require('./words');

s.pad              = require('./pad');

s.lpad             = require('./lpad');

s.rpad             = require('./rpad');

s.lrpad            = require('./lrpad');

s.sprintf          = require('./sprintf');

s.vsprintf         = require('./vsprintf');

s.toNumber         = require('./toNumber');

s.numberFormat     = require('./numberFormat');

s.strRight         = require('./strRight');

s.strRightBack     = require('./strRightBack');

s.strLeft          = require('./strLeft');

s.strLeftBack      = require('./strLeftBack');

s.toSentence       = require('./toSentence');

s.toSentenceSerial = require('./toSentenceSerial');

s.slugify          = require('./slugify');

s.surround         = require('./surround');

s.quote            = require('./quote');

s.unquote          = require('./unquote');

s.repeat           = require('./repeat');

s.naturalCmp       = require('./naturalCmp');

s.levenshtein      = require('./levenshtein');

s.toBoolean        = require('./toBoolean');

s.exports          = require('./exports');

s.escapeRegExp     = require('./helper/escapeRegExp');

s.wrap             = require('./wrap');

s.map              = require('./map');

// Aliases

s.strip     = s.trim;

s.lstrip    = s.ltrim;

s.rstrip    = s.rtrim;

s.center    = s.lrpad;

s.rjust     = s.lpad;

s.ljust     = s.rpad;

s.contains  = s.include;

s.q         = s.quote;

s.toBool    = s.toBoolean;

s.camelcase = s.camelize;

s.mapChars  = s.map;

// Implement chaining

s.prototype = {

  value: function value() {

    return this._wrapped;

  }

};

function fn2method(key, fn) {

  if (typeof fn !== 'function') return;

  s.prototype[key] = function() {

    var args = [this._wrapped].concat(Array.prototype.slice.call(arguments));

    var res = fn.apply(null, args);

    // if the result is non-string stop the chain and return the value

  };

}

// Copy functions to instance methods for chaining

fn2method('tap', function tap(string, fn) {

  return fn(string);

});

function prototype2method(methodName) {

  fn2method(methodName, function(context) {

    var args = Array.prototype.slice.call(arguments, 1);

    return String.prototype[methodName].apply(context, args);

  });

}

var prototypeMethods = [

  'toUpperCase',

  'toLowerCase',

  'split',

  'replace',

  'slice',

  'substring',

  'substr',

  'concat'

];

module.exports = s;

},{"./camelize":1,"./capitalize":2,"./chars":3,"./chop":4,"./classify":5,"./clean":6,"./cleanDiacritics":7,"./count":8,"./dasherize":9,"./decapitalize":10,"./dedent":11,"./endsWith":12,"./escapeHTML":13,"./exports":14,"./helper/escapeRegExp":18,"./humanize":23,"./include":24,"./insert":26,"./isBlank":27,"./join":28,"./levenshtein":29,"./lines":30,"./lpad":31,"./lrpad":32,"./ltrim":33,"./map":34,"./naturalCmp":35,"./numberFormat":38,"./pad":39,"./pred":40,"./prune":41,"./quote":42,"./repeat":43,"./replaceAll":44,"./reverse":45,"./rpad":46,"./rtrim":47,"./slugify":48,"./splice":49,"./sprintf":50,"./startsWith":51,"./strLeft":52,"./strLeftBack":53,"./strRight":54,"./strRightBack":55,"./stripTags":56,"./succ":57,"./surround":58,"./swapCase":59,"./titleize":60,"./toBoolean":61,"./toNumber":62,"./toSentence":63,"./toSentenceSerial":64,"./trim":65,"./truncate":66,"./underscored":67,"./unescapeHTML":68,"./unquote":69,"./vsprintf":70,"./words":71,"./wrap":72}],26:[function(require,module,exports){

var splice = require('./splice');

module.exports = function insert(str, i, substr) {

  return splice(str, i, 0, substr);

};

},{"./splice":49}],27:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function isBlank(str) {

  return (/^\s*$/).test(makeString(str));

};

},{"./helper/makeString":20}],28:[function(require,module,exports){

var makeString = require('./helper/makeString');

var slice = [].slice;

module.exports = function join() {

  var args = slice.call(arguments),

    separator = args.shift();

  return args.join(makeString(separator));

};

},{"./helper/makeString":20}],29:[function(require,module,exports){

var makeString = require('./helper/makeString');

/**

 * Based on the implementation here: https://github.com/hiddentao/fast-levenshtein

 */

},{"./helper/makeString":20}],30:[function(require,module,exports){

module.exports = function lines(str) {

  if (str == null) return [];

  return String(str).split(/\r\n?|\n/);

};

},{}],31:[function(require,module,exports){

var pad = require('./pad');

module.exports = function lpad(str, length, padStr) {

  return pad(str, length, padStr);

};

},{"./pad":39}],32:[function(require,module,exports){

var pad = require('./pad');

module.exports = function lrpad(str, length, padStr) {

  return pad(str, length, padStr, 'both');

};

},{"./pad":39}],33:[function(require,module,exports){

var makeString = require('./helper/makeString');

var defaultToWhiteSpace = require('./helper/defaultToWhiteSpace');

var nativeTrimLeft = String.prototype.trimLeft;

module.exports = function ltrim(str, characters) {

  str = makeString(str);

  if (!characters && nativeTrimLeft) return nativeTrimLeft.call(str);

  characters = defaultToWhiteSpace(characters);

  return str.replace(new RegExp('^' + characters + '+'), '');

};

},{"./helper/defaultToWhiteSpace":16,"./helper/makeString":20}],34:[function(require,module,exports){

var makeString = require('./helper/makeString');

module.exports = function(str, callback) {

  str = makeString(str);

  if (str.length === 0 || typeof callback !== 'function') return str;

  return str.replace(/./g, callback);

};

},{"./helper/makeString":20}],35:[function(require,module,exports){

module.exports = function naturalCmp(str1, str2) {

  if (str1 == str2) return 0;

  if (!str1) return -1;

  if (!str2) return 1;

  var cmpRegex = /(\.\d+|\d+|\D+)/g,

    tokens1 = String(str1).match(cmpRegex),

    tokens2 = String(str2).match(cmpRegex),

    count = Math.min(tokens1.length, tokens2.length);

  for (var i = 0; i < count; i++) {

    var a = tokens1[i],

      b = tokens2[i];

    if (a !== b) {

      var num1 = +a;

      var num2 = +b;

      if (num1 === num1 && num2 === num2) {

        return num1 > num2 ? 1 : -1;

      }

      return a < b ? -1 : 1;

    }

  }

  if (tokens1.length != tokens2.length)

    return tokens1.length - tokens2.length;

  return str1 < str2 ? -1 : 1;

};

},{}],36:[function(require,module,exports){

(function(window) {

    var re = {

        not_string: /[^s]/,

        number: /[diefg]/,

        json: /[j]/,

        not_json: /[^j]/,

        text: /^[^\x25]+/,

        modulo: /^\x25{2}/,

        placeholder: /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijosuxX])/,

        key: /^([a-z_][a-z_\d]*)/i,

        key_access: /^\.([a-z_][a-z_\d]*)/i,

        index_access: /^\[(\d+)\]/,

        sign: /^[\+\-]/

    }

    function sprintf() {

        var key = arguments[0], cache = sprintf.cache

        if (!(cache[key] && cache.hasOwnProperty(key))) {

            cache[key] = sprintf.parse(key)

        }

        return sprintf.format.call(null, cache[key], arguments)

    }

    sprintf.format = function(parse_tree, argv) {

        var cursor = 1, tree_length = parse_tree.length, node_type = "", arg, output = [], i, k, match, pad, pad_character, pad_length, is_positive = true, sign = ""

        for (i = 0; i < tree_length; i++) {

            node_type = get_type(parse_tree[i])

            if (node_type === "string") {

                output[output.length] = parse_tree[i]

            }

            else if (node_type === "array") {

                match = parse_tree[i] // convenience purposes only

                if (match[2]) { // keyword argument

                    arg = argv[cursor]

                    for (k = 0; k < match[2].length; k++) {

                        if (!arg.hasOwnProperty(match[2][k])) {

                            throw new Error(sprintf("[sprintf] property '%s' does not exist", match[2][k]))

                        }

                        arg = arg[match[2][k]]

                    }

                }

                else if (match[1]) { // positional argument (explicit)

                    arg = argv[match[1]]

                }

                else { // positional argument (implicit)

                    arg = argv[cursor++]

                }

                if (get_type(arg) == "function") {

                    arg = arg()

                }

                if (re.not_string.test(match[8]) && re.not_json.test(match[8]) && (get_type(arg) != "number" && isNaN(arg))) {

                    throw new TypeError(sprintf("[sprintf] expecting number but found %s", get_type(arg)))

                }

                if (re.number.test(match[8])) {

                    is_positive = arg >= 0

                }

                    case "b":

                        arg = arg.toString(2)

                    break

                    case "c":

                        arg = String.fromCharCode(arg)

                    break

                    case "d":

                    case "i":

                        arg = parseInt(arg, 10)

                    break

                    case "j":

                        arg = JSON.stringify(arg, null, match[6] ? parseInt(match[6]) : 0)

                    break

                    case "e":

                        arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential()

                    break

                    case "f":

                        arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg)

                    break

                    case "g":

                        arg = match[7] ? parseFloat(arg).toPrecision(match[7]) : parseFloat(arg)

                    break

                    case "o":

                        arg = arg.toString(8)

                    break

                    case "s":

                        arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg)

                    break

                    case "u":

                        arg = arg >>> 0

                    break

                    case "x":

                        arg = arg.toString(16)

                    break

                    case "X":

                        arg = arg.toString(16).toUpperCase()

                    break

                }

                if (re.json.test(match[8])) {

                    output[output.length] = arg

                }

                else {

                    if (re.number.test(match[8]) && (!is_positive || match[3])) {

                        sign = is_positive ? "+" : "-"

                        arg = arg.toString().replace(re.sign, "")

                    }

                    else {

                        sign = ""

                    }

                    pad_character = match[4] ? match[4] === "0" ? "0" : match[4].charAt(1) : " "

                    pad_length = match[6] - (sign + arg).length

                    pad = match[6] ? (pad_length > 0 ? str_repeat(pad_character, pad_length) : "") : ""

                    output[output.length] = match[5] ? sign + arg + pad : (pad_character === "0" ? sign + pad + arg : pad + sign + arg)

                }

            }

        }

        return output.join("")

    }

    sprintf.cache = {}

    sprintf.parse = function(fmt) {

        while (_fmt) {

            if ((match = re.text.exec(_fmt)) !== null) {

                parse_tree[parse_tree.length] = match[0]

            }

            else if ((match = re.modulo.exec(_fmt)) !== null) {

                parse_tree[parse_tree.length] = "%"

            }

            else if ((match = re.placeholder.exec(_fmt)) !== null) {

                if (match[2]) {

                    arg_names |= 1

                    if ((field_match = re.key.exec(replacement_field)) !== null) {

                        field_list[field_list.length] = field_match[1]

                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") {

                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {

                                field_list[field_list.length] = field_match[1]

                            }

                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {

                                field_list[field_list.length] = field_match[1]

                            }

                            else {

                                throw new SyntaxError("[sprintf] failed to parse named argument key")

                            }

                        }

                    }

                    else {

                        throw new SyntaxError("[sprintf] failed to parse named argument key")

                    }

                    match[2] = field_list

                }

                else {

                    arg_names |= 2

                }

                if (arg_names === 3) {

                    throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported")

                }

                parse_tree[parse_tree.length] = match

            }

            else {

                throw new SyntaxError("[sprintf] unexpected placeholder")

            }

            _fmt = _fmt.substring(match[0].length)

        }

        return parse_tree

    }

    var vsprintf = function(fmt, argv, _argv) {

        _argv = (argv || []).slice(0)

        _argv.splice(0, 0, fmt)

        return sprintf.apply(null, _argv)

    }

    /**

     * helpers

     */

    function get_type(variable) {

        return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase()

    }

    function str_repeat(input, multiplier) {

        return Array(multiplier + 1).join(input)

    }

    /**

     * export to either browser or node.js

     */

    if (typeof exports !== "undefined") {

        exports.sprintf = sprintf

        exports.vsprintf = vsprintf

    }

    else {

        window.sprintf = sprintf

        window.vsprintf = vsprintf

            define(function() {

                return {

                    sprintf: sprintf,

                    vsprintf: vsprintf

                }

            })

        }

    }

})(typeof window === "undefined" ? this : window);

},{}],37:[function(require,module,exports){

(function (global){

/**

 * Module exports.

 */

module.exports = deprecate;

/**

 * Mark that a method should not be used.

 * Returns a modified function which warns once by default.

 *

 * If `localStorage.noDeprecation = true` is set, then it is a no-op.

 *

 * If `localStorage.throwDeprecation = true` is set, then deprecated functions

 * will throw an Error when invoked.

 *

 * If `localStorage.traceDeprecation = true` is set, then deprecated functions

 * will invoke `console.trace()` instead of `console.error()`.

 *

 * @param {Function} fn - the function to deprecate

 * @param {String} msg - the string to print to the console when `fn` is invoked

 * @returns {Function} a new "deprecated" version of `fn`

 * @api public

 */

function deprecate (fn, msg) {

  if (config('noDeprecation')) {

    return fn;

  }

  var warned = false;

  function deprecated() {

    if (!warned) {

      if (config('throwDeprecation')) {

        throw new Error(msg);

      } else if (config('traceDeprecation')) {

        console.trace(msg);

      } else {

        console.warn(msg);

      }

      warned = true;

    }

    return fn.apply(this, arguments);

  }

  return deprecated;

}

/**

 * Checks `localStorage` for boolean values for the given `name`.

 *

 * @param {String} name

 * @returns {Boolean}

 * @api private

 */

function config (name) {

  // accessing global.localStorage can trigger a DOMException in sandboxed iframes

  try {

    if (!global.localStorage) return false;

  } catch (_) {

    return false;

  }

  var val = global.localStorage[name];

  if (null == val) return false;

  return String(val).toLowerCase() === 'true';

}

},{}],38:[function(require,module,exports){

module.exports = function numberFormat(number, dec, dsep, tsep) {

  if (isNaN(number) || number == null) return '';

  number = number.toFixed(~~dec);

  tsep = typeof tsep == 'string' ? tsep : ',';

  var parts = number.split('.'),

    fnums = parts[0],

    decimals = parts[1] ? (dsep || '.') + parts[1] : '';

  return fnums.replace(/(\d)(?=(?:\d{3})+$)/g, '$1' + tsep) + decimals;

};

},{}],39:[function(require,module,exports){

var makeString = require('./helper/makeString');

var strRepeat = require('./helper/strRepeat');

module.exports = function pad(str, length, padStr, type) {

  str = makeString(str);

  length = ~~length;

  var padlen = 0;

  if (!padStr)

    padStr = ' ';

  else if (padStr.length > 1)

    padStr = padStr.charAt(0);

  switch (type) {

  case 'right':

    padlen = length - str.length;

    return str + strRepeat(padStr, padlen);

  case 'both':

    padlen = length - str.length;

    return strRepeat(padStr, Math.ceil(padlen / 2)) + str + strRepeat(padStr, Math.floor(padlen / 2));

  default: // 'left'

    padlen = length - str.length;

    return strRepeat(padStr, padlen) + str;

  }

};

},{"./helper/makeString":20,"./helper/strRepeat":21}],40:[function(require,module,exports){

var adjacent = require('./helper/adjacent');

module.exports = function succ(str) {

  return adjacent(str, -1);

};

},{"./helper/adjacent":15}],41:[function(require,module,exports){

/**

 * _s.prune: a more elegant version of truncate

 * prune extra chars, never leaving a half-chopped word.

 * @author github.com/rwz

 */

var makeString = require('./helper/makeString');

var rtrim = require('./rtrim');

module.exports = function prune(str, length, pruneStr) {

  str = makeString(str);

  length = ~~length;

  pruneStr = pruneStr != null ? String(pruneStr) : '...';

  if (str.length <= length) return str;

  var tmpl = function(c) {

      return c.toUpperCase() !== c.toLowerCase() ? 'A' : ' ';

    },

    template = str.slice(0, length + 1).replace(/.(?=\W*\w*$)/g, tmpl); // 'Hello, world' -> 'HellAA AAAAA'

  if (template.slice(template.length - 2).match(/\w\w/))

    template = template.replace(/\s*\S+$/, '');

  else

    template = rtrim(template.slice(0, template.length - 1));

  return (template + pruneStr).length > str.length ? str : str.slice(0, template.length) + pruneStr;

};

},{"./helper/makeString":20,"./rtrim":47}],42:[function(require,module,exports){

var surround = require('./surround');